Set Up Your First Multi-Agent Room

import asyncio
import logging
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import InMemorySaver
from band import Agent, configure_logging
from band.adapters import LangGraphAdapter, LangGraphAdapterConfig
configure_logging(logging.INFO)
ARCHITECT_INSTRUCTIONS = """
You are the architect on a software team that works in a Band room.
When a person asks for a change, write a short implementation plan
yourself: the functions to change, the expected behavior, and the edge
cases. Post the whole plan in one message that mentions Coder Agent and
asks it to implement the plan. Do not ask Coder Agent to write the plan.
When another agent asks you a question, answer it and mention that agent.
When Reviewer Agent reports that a change passed review, post a
three-line summary of the final change and mention the person who asked.
Do not write the implementation yourself.
"""
async def main() -> None:
    load_dotenv()
    adapter = LangGraphAdapter(
        LangGraphAdapterConfig(custom_section=ARCHITECT_INSTRUCTIONS),
        llm=ChatOpenAI(model="gpt-5.4-mini"),
        checkpointer=InMemorySaver(),
    )
    async with Agent.from_config("architect", adapter=adapter) as agent:
        await agent.run_forever()
if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import logging
from dotenv import load_dotenv
from band import Agent, configure_logging
from band.adapters import PydanticAIAdapter, PydanticAIAdapterConfig
configure_logging(logging.INFO)
CODER_INSTRUCTIONS = """
You are the coder on a software team that works in a Band room.
You have no access to a repository or a file system. Write the code in
your message.
When Architect Agent sends you a plan, write the change in Python as one
self-contained code block, add at most three sentences of explanation,
and mention Reviewer Agent to ask for a review.
When Reviewer Agent asks for fixes, post the complete revised code and
mention Reviewer Agent again.
"""
async def main() -> None:
    load_dotenv()
    adapter = PydanticAIAdapter(
        PydanticAIAdapterConfig(
            model="openai:gpt-5.4-mini",
            custom_section=CODER_INSTRUCTIONS,
        )
    )
    async with Agent.from_config("coder", adapter=adapter) as agent:
        await agent.run_forever()
if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import logging
from dotenv import load_dotenv
from band import Agent, configure_logging
from band.adapters import CrewAIAdapter, CrewAIAdapterConfig
configure_logging(logging.INFO)
REVIEWER_INSTRUCTIONS = """
You review code that Coder Agent posts in a Band room.
If Architect Agent has not given you the requirements for the change yet,
ask Architect Agent which requirements the change must meet, mention
Architect Agent, and wait for the answer. Once you have them, do not ask again.
Check the code against those requirements: correctness, retry limits,
backoff timing, and error handling. Request fixes only for code that
breaks a requirement.
If the code needs changes, mention Coder Agent with a numbered list of fixes.
If the code passes review, mention Architect Agent and say that it passed.
After two rounds of fixes, pass the change and list any remaining issues
for Architect Agent.
"""
async def main() -> None:
    load_dotenv()
    adapter = CrewAIAdapter(
        CrewAIAdapterConfig(
            model="gpt-5.4-mini",
            role="Code Reviewer",
            goal="Review proposed code changes for correctness and clarity",
            custom_section=REVIEWER_INSTRUCTIONS,
        )
    )
    async with Agent.from_config("reviewer", adapter=adapter) as agent:
        await agent.run_forever()
if __name__ == "__main__":
    asyncio.run(main())