Atharva Pandey/Lesson 6: Agent Architectures — Building autonomous agents in Go

// WRONG — rigid sequential pipeline, no adaptation
func analyzeBug(report string) string {
    // Step 1: Ask model what code to look at
    files := llm.Ask("Given bug report, what files are relevant? " + report)
    // Step 2: Always read exactly those files
    contents := readFiles(parseFileList(files))
    // Step 3: Always ask for analysis
    analysis := llm.Ask("Analyze this code: " + contents)
    // Step 4: Always return analysis
    return analysis
}
// If step 1 suggests running a test, this code can't do that.
// If the analysis reveals another file is needed, this code can't fetch it.

// agent/executor.go
package agent

import (
    "context"
    "fmt"
    "log/slog"
)

type Executor struct {
    llm     LLMClient
    tools   ToolRegistry
    memory  Memory
    maxSteps int
}

type Step struct {
    Thought string
    Action  *ToolCall
    Result  string
}

type ToolCall struct {
    Name  string
    Input json.RawMessage
}

func NewExecutor(llm LLMClient, tools ToolRegistry, mem Memory) *Executor {
    return &Executor{
        llm:     llm,
        tools:   tools,
        memory:  mem,
        maxSteps: 20, // prevent runaway agents
    }
}

func (e *Executor) Run(ctx context.Context, task string) (string, error) {
    // Initialize conversation with the task
    messages := []Message{
        {Role: "user", Content: task},
    }

    var steps []Step

    for i := 0; i < e.maxSteps; i++ {
        // Check if context is cancelled
        if err := ctx.Err(); err != nil {
            return "", fmt.Errorf("agent cancelled after %d steps: %w", i, err)
        }

        // Get the model's next action
        resp, err := e.llm.MessagesWithTools(ctx, MessagesRequest{
            System:    e.buildSystemPrompt(),
            Messages:  messages,
            Tools:     e.tools.Definitions(),
            MaxTokens: 4096,
        })
        if err != nil {
            return "", fmt.Errorf("step %d: llm error: %w", i, err)
        }

        // Add assistant message to history
        messages = append(messages, Message{
            Role:    "assistant",
            Content: resp.Content,
        })

        // If no tool use, the agent is done
        if resp.StopReason != "tool_use" {
            for _, block := range resp.Content {
                if block.Type == "text" {
                    slog.Info("agent complete", "steps", i, "task", task[:min(50, len(task))])
                    return block.Text, nil
                }
            }
            return "", fmt.Errorf("agent finished with no text response")
        }

        // Execute tool calls (potentially concurrent for independent tools)
        toolResults, err := e.executeTools(ctx, resp.Content)
        if err != nil {
            return "", fmt.Errorf("step %d: tool execution: %w", i, err)
        }

        // Add tool results to conversation
        messages = append(messages, Message{
            Role:    "user",
            Content: toolResults,
        })

        // Log the step for observability
        steps = append(steps, Step{Result: fmt.Sprintf("Completed %d tool calls", len(toolResults))})
    }

    return "", fmt.Errorf("agent exceeded max steps (%d)", e.maxSteps)
}

// Execute multiple tool calls concurrently when they don't depend on each other
func (e *Executor) executeTools(ctx context.Context, blocks []ContentBlock) ([]ToolResult, error) {
    var toolUseBlocks []ContentBlock
    for _, b := range blocks {
        if b.Type == "tool_use" {
            toolUseBlocks = append(toolUseBlocks, b)
        }
    }

    type result struct {
        idx    int
        result ToolResult
        err    error
    }

    results := make(chan result, len(toolUseBlocks))

    for i, block := range toolUseBlocks {
        i, block := i, block
        go func() {
            output, err := e.tools.Execute(ctx, block.Name, block.Input)
            if err != nil {
                output = fmt.Sprintf("Tool error: %s", err.Error())
                slog.Warn("tool failed", "tool", block.Name, "err", err)
            }
            results <- result{
                idx: i,
                result: ToolResult{
                    Type:      "tool_result",
                    ToolUseID: block.ID,
                    Content:   output,
                },
            }
        }()
    }

    toolResults := make([]ToolResult, len(toolUseBlocks))
    for range toolUseBlocks {
        r := <-results
        toolResults[r.idx] = r.result
    }

    return toolResults, nil
}

func (e *Executor) buildSystemPrompt() string {
    return `You are an autonomous agent. For each task:
1. Think about what information you need
2. Use tools to gather that information
3. Continue reasoning and using tools until you have a complete answer
4. Provide a clear, concise final response

Guidelines:
- Use tools when you need current information, not just your training knowledge
- When multiple tools can be called independently, call them in the same response
- If a tool returns an error, try to recover or explain what went wrong
- Always provide a final text response when you're done working`
}