Multi-Agent Scenarios

client, err := sdk.NewClient(&sdk.ClientConfig{
    Model: sdk.ModelIdentifier{
        Provider: sdk.APIProviderAnthropic,
        Model:    "claude-sonnet-4-20250514",
    },
    APIKey:         os.Getenv("ANTHROPIC_API_KEY"),
    WorkingDir:     repoRoot,
    PermissionMode: sdk.PermissionModeOnRequest,
    RuntimeEventFn: func(event sdk.RuntimeEvent) {
        switch string(event.Type) {
        case "agent.spawn.begin", "agent.spawn.end", "agent.wait.begin", "agent.wait.end":
            if event.AgentEvent != nil {
                log.Printf(
                    "agent=%s role=%s status=%s type=%s",
                    event.AgentEvent.AgentID,
                    event.AgentEvent.AgentRole,
                    event.AgentEvent.Status,
                    event.Type,
                )
            }
        }
    },
})
if err != nil {
    log.Fatal(err)
}
defer client.Close()

session, err := client.CreateSession(ctx)
if err != nil {
    log.Fatal(err)
}
defer session.Close()

session.SetAppendSystemPrompt(`If the task benefits from delegation, use the built-in
agent tools. Prefer a researcher, implementer, and reviewer split.
Wait for spawned agents before returning the final synthesis.`)

resp, err := session.SubmitMessage(ctx, `Inspect this repository. Research the bug,
propose the patch, and review the risk before you answer.`)
if err != nil {
    log.Fatal(err)
}

fmt.Println(resp.Content)

type RoleResult struct {
    Role   string
    Output string
}

runRole := func(ctx context.Context, role string, instruction string) (RoleResult, error) {
    session, err := client.CreateSession(ctx)
    if err != nil {
        return RoleResult{}, err
    }
    defer session.Close()

    session.SetSystemPromptTemplate(fmt.Sprintf(`You are the %s agent.
Stay focused on your role and return structured output.`, role))

    resp, err := session.SubmitMessage(ctx, instruction)
    if err != nil {
        return RoleResult{}, err
    }

    return RoleResult{Role: role, Output: resp.Content}, nil
}

var (
    g       errgroup.Group
    mu      sync.Mutex
    results []RoleResult
)

for role, task := range map[string]string{
    "researcher": "Investigate the bug reports and likely root cause.",
    "engineer":   "Draft the implementation strategy and patch outline.",
    "reviewer":   "List the highest-risk regressions and missing tests.",
} {
    role := role
    task := task
    g.Go(func() error {
        result, err := runRole(ctx, role, task)
        if err != nil {
            return err
        }
        mu.Lock()
        results = append(results, result)
        mu.Unlock()
        return nil
    })
}

if err := g.Wait(); err != nil {
    log.Fatal(err)
}

payload, err := json.MarshalIndent(results, "", "  ")
if err != nil {
    log.Fatal(err)
}

manager, err := client.CreateSession(ctx)
if err != nil {
    log.Fatal(err)
}
defer manager.Close()

manager.SetAppendSystemPrompt("Synthesize specialist outputs into one decisive plan.")

resp, err := manager.SubmitMessage(ctx, string(payload))
if err != nil {
    log.Fatal(err)
}

fmt.Println(resp.Content)

database, err := db.Open(ctx, db.Config{
    Driver:      db.DriverSQLite,
    DSN:         "seshat.db",
    AutoMigrate: true,
})
if err != nil {
    log.Fatal(err)
}

profiles := agent.NewProfileRegistry(database)
teams := team.NewTeamRegistry(database)
_ = profiles.Seed(ctx)

agentLister := func(ctx context.Context, teamID string) ([]string, error) {
    members, err := teams.Members(ctx, teamID)
    if err != nil {
        return nil, err
    }

    ids := make([]string, 0, len(members))
    for _, member := range members {
        ids = append(ids, member.ID)
    }
    return ids, nil
}

mail := mailbox.New(database, agentLister)
dispatcher := team.NewDispatcher(profiles, mail)

handler := team.NewSessionHandler(engineInstance, nil, profiles, teams)
bus := team.NewTeamBus(profiles, mail, handler, 2*time.Second)
bus.Start(ctx)
defer bus.Stop()

_ = dispatcher.Assign(
    ctx,
    orchestratorID,
    "researcher",
    "alpha",
    "Research competitors",
    "Summarise pricing, positioning, and distribution channels.",
)