Groups

1
from letta_client import Letta, SleeptimeManager
2
3
client = Letta()
4
5
# Create main conversation agent
6
main_agent = client.agents.create(
7
    model="openai/gpt-4.1",
8
    memory_blocks=[
9
        {"label": "persona", "value": "I am the main conversation agent"}
10
    ]
11
)
12
13
# Create sleeptime agents for background tasks
14
monitor_agent = client.agents.create(
15
    model="openai/gpt-4.1",
16
    memory_blocks=[
17
        {"label": "persona", "value": "I monitor conversation sentiment and key topics"}
18
    ]
19
)
20
21
summary_agent = client.agents.create(
22
    model="openai/gpt-4.1",
23
    memory_blocks=[
24
        {"label": "persona", "value": "I create periodic summaries of the conversation"}
25
    ]
26
)
27
28
# Create a Sleeptime group
29
group = client.groups.create(
30
    agent_ids=[monitor_agent.id, summary_agent.id],
31
    description="Background agents that process conversation periodically",
32
    manager_config=SleeptimeManager(
33
        manager_agent_id=main_agent.id,
34
        sleeptime_agent_frequency=3  # Execute every 3 turns
35
    )
36
)
37
38
# Send messages to the group
39
response = client.groups.messages.send(
40
    group_id=group.id,
41
    message="Let's discuss our project roadmap"
42
)

1
from letta_client import Letta, RoundRobinManager
2
3
client = Letta()
4
5
# Create agents for the group
6
agent1 = client.agents.create(
7
    model="openai/gpt-4.1",
8
    memory_blocks=[
9
        {"label": "persona", "value": "I am the first agent in the group"}
10
    ]
11
)
12
13
agent2 = client.agents.create(
14
    model="openai/gpt-4.1",
15
    memory_blocks=[
16
        {"label": "persona", "value": "I am the second agent in the group"}
17
    ]
18
)
19
20
agent3 = client.agents.create(
21
    model="openai/gpt-4.1",
22
    memory_blocks=[
23
        {"label": "persona", "value": "I am the third agent in the group"}
24
    ]
25
)
26
27
# Create a RoundRobin group
28
group = client.groups.create(
29
    agent_ids=[agent1.id, agent2.id, agent3.id],
30
    description="A group that cycles through agents in order",
31
    manager_config=RoundRobinManager(
32
        max_turns=3  # Optional: defaults to number of agents
33
    )
34
)
35
36
# Send a message to the group
37
response = client.groups.messages.send(
38
    group_id=group.id,
39
    message="Hello group, what are your thoughts on this topic?"
40
)

1
from letta_client import Letta, SupervisorManager
2
3
client = Letta()
4
5
# Create supervisor agent
6
supervisor = client.agents.create(
7
    model="openai/gpt-4.1",
8
    memory_blocks=[
9
        {"label": "persona", "value": "I am a supervisor managing multiple workers"}
10
    ]
11
)
12
13
# Create worker agents
14
worker1 = client.agents.create(
15
    model="openai/gpt-4.1",
16
    memory_blocks=[
17
        {"label": "persona", "value": "I am a data analysis specialist"}
18
    ]
19
)
20
21
worker2 = client.agents.create(
22
    model="openai/gpt-4.1",
23
    memory_blocks=[
24
        {"label": "persona", "value": "I am a research specialist"}
25
    ]
26
)
27
28
worker3 = client.agents.create(
29
    model="openai/gpt-4.1",
30
    memory_blocks=[
31
        {"label": "persona", "value": "I am a writing specialist"}
32
    ]
33
)
34
35
# Create a Supervisor group
36
group = client.groups.create(
37
    agent_ids=[worker1.id, worker2.id, worker3.id],
38
    description="A supervisor-worker group for parallel task execution",
39
    manager_config=SupervisorManager(
40
        manager_agent_id=supervisor.id
41
    )
42
)
43
44
# Send a message to the group
45
response = client.groups.messages.send(
46
    group_id=group.id,
47
    message="Analyze this data and prepare a report"
48
)

1
from letta_client import Letta, DynamicManager
2
3
client = Letta()
4
5
# Create orchestrator agent
6
orchestrator = client.agents.create(
7
    model="openai/gpt-4.1",
8
    memory_blocks=[
9
        {"label": "persona", "value": "I am an orchestrator that decides who speaks next based on context"}
10
    ]
11
)
12
13
# Create participant agents
14
expert1 = client.agents.create(
15
    model="openai/gpt-4.1",
16
    memory_blocks=[
17
        {"label": "persona", "value": "I am a technical expert"}
18
    ]
19
)
20
21
expert2 = client.agents.create(
22
    model="openai/gpt-4.1",
23
    memory_blocks=[
24
        {"label": "persona", "value": "I am a business strategist"}
25
    ]
26
)
27
28
expert3 = client.agents.create(
29
    model="openai/gpt-4.1",
30
    memory_blocks=[
31
        {"label": "persona", "value": "I am a creative designer"}
32
    ]
33
)
34
35
# Create a Dynamic group
36
group = client.groups.create(
37
    agent_ids=[expert1.id, expert2.id, expert3.id],
38
    description="A dynamic group where the orchestrator chooses speakers",
39
    manager_config=DynamicManager(
40
        manager_agent_id=orchestrator.id,
41
        termination_token="DONE!",  # Optional: default is "DONE!"
42
        max_turns=10  # Optional: prevent infinite loops
43
    )
44
)
45
46
# Send a message to the group
47
response = client.groups.messages.send(
48
    group_id=group.id,
49
    message="Let's design a new product. Who should start?"
50
)