Harness orchestration

from pydantic import BaseModel
from agentfield import Agent, HarnessConfig

# No provider, no model -- this agent's harness calls run on AForge.
app = Agent(node_id="migrator", harness_config=HarnessConfig())

class MigrationPlan(BaseModel):
    sql_statements: list[str]
    rollback_steps: list[str]
    risk_assessment: str

@app.reasoner()
async def plan_migration(description: str) -> dict:
    # Harness reads the schema, writes SQL, validates against the Pydantic model
    result = await app.harness(
        f"Analyze the database schema and produce a migration plan for: {description}",
        schema=MigrationPlan,
        max_turns=20,   # turn cap -- AForge stops cleanly when it is hit
    )

    if result.is_error:
        return {"error": result.failure_type, "message": result.error_message}

    plan: MigrationPlan = result.parsed
    return {
        "sql": plan.sql_statements,
        "rollback": plan.rollback_steps,
        "cost_usd": result.cost_usd,
        "turns": result.num_turns,
    }

# Swap workers per-call -- Codex for test generation, Gemini for big refactors
@app.reasoner()
async def write_tests(module: str) -> dict:
    result = await app.harness(
        f"Write a comprehensive test suite for {module}.",
        provider="codex",
        model="o4-mini",
        max_turns=40,
    )
    return {"output": result.text, "cost_usd": result.cost_usd}

app.run()

import { Agent, type HarnessConfig } from "@agentfield/sdk";
import { z } from "zod";

// No provider, no model -- this agent's harness calls run on AForge.
const harnessConfig: HarnessConfig = {};
const app = new Agent({ nodeId: "migrator", harnessConfig });

const MigrationPlan = z.object({
  sqlStatements: z.array(z.string()),
  rollbackSteps: z.array(z.string()),
  riskAssessment: z.string(),
});

app.reasoner("plan_migration", async (ctx) => {
  // Harness reads the schema, writes SQL, validates against the Zod model
  const result = await app.harness(
    `Analyze the database schema and produce a migration plan for: ${ctx.input.description}`,
    {
      schema: MigrationPlan,
      maxTurns: 20,   // turn cap -- AForge stops cleanly when it is hit
    },
  );

  if (result.isError) {
    return { error: result.errorMessage };
  }

  const plan = MigrationPlan.parse(result.parsed);
  return {
    sql: plan.sqlStatements,
    rollback: plan.rollbackSteps,
    costUsd: result.costUsd,
    turns: result.numTurns,
  };
});

// Swap workers per-call -- Codex for test generation, Gemini for big refactors
app.reasoner("write_tests", async (ctx) => {
  const result = await app.harness(
    `Write a comprehensive test suite for ${ctx.input.module}.`,
    { provider: "codex", model: "o4-mini", maxTurns: 40 },
  );
  return { output: result.text, costUsd: result.costUsd };
});

app.serve();

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Agent-Field/agentfield/sdk/go/agent"
    "github.com/Agent-Field/agentfield/sdk/go/harness"
)

type MigrationPlan struct {
    SQLStatements  []string `json:"sql_statements"`
    RollbackSteps  []string `json:"rollback_steps"`
    RiskAssessment string   `json:"risk_assessment"`
}

func main() {
    a, err := agent.New(agent.Config{
        NodeID:        "migrator",
        Version:       "1.0.0",
        AgentFieldURL: "http://localhost:8080",
        // No Provider, no Model -- this agent's harness calls run on AForge.
        HarnessConfig: &agent.HarnessConfig{},
    })
    if err != nil {
        log.Fatal(err)
    }

    a.RegisterReasoner("plan_migration", func(ctx context.Context, input map[string]any) (any, error) {
        description := fmt.Sprintf("%v", input["description"])

        // Harness reads the schema, writes SQL, validates against the struct
        var plan MigrationPlan
        schema, _ := harness.StructToJSONSchema(plan)

        result, err := a.Harness(ctx,
            "Analyze the database schema and produce a migration plan for: "+description,
            schema, &plan,
            harness.Options{MaxTurns: 20}, // turn cap -- AForge stops cleanly when it is hit
        )
        if err != nil {
            return nil, err
        }
        if result.IsError {
            return map[string]any{"error": result.ErrorMessage}, nil
        }

        return map[string]any{
            "sql":      plan.SQLStatements,
            "rollback": plan.RollbackSteps,
            "turns":    result.NumTurns,
        }, nil
    })

    // Swap workers per-call -- Codex for test generation, Gemini for big refactors
    a.RegisterReasoner("write_tests", func(ctx context.Context, input map[string]any) (any, error) {
        module := fmt.Sprintf("%v", input["module"])
        result, err := a.Harness(ctx,
            "Write a comprehensive test suite for "+module+".",
            nil, nil,
            harness.Options{Provider: "codex", Model: "o4-mini", MaxTurns: 40},
        )
        if err != nil {
            return nil, err
        }
        return map[string]any{"output": result.Text()}, nil
    })

    a.Serve(context.Background())
}

# Same reasoner, different worker -- and claude-code is the provider that enforces max_budget_usd.
plan = await app.harness(
    prompt, schema=MigrationPlan, provider="claude-code", max_budget_usd=1.00
)

# Or set it once for the whole agent.
app = Agent(node_id="migrator", harness_config=HarnessConfig(provider="claude-code"))

// Same reasoner, different worker -- and claude-code is the provider that enforces maxBudgetUsd.
const plan = await app.harness(prompt, {
  schema: MigrationPlan,
  provider: "claude-code",
  maxBudgetUsd: 1.0,
});

// Or set it once for the whole agent.
const app = new Agent({ nodeId: "migrator", harnessConfig: { provider: "claude-code" } });

// Same reasoner, different worker -- and claude-code is the provider that enforces MaxBudgetUSD.
result, err := a.Harness(ctx, prompt, schema, &plan,
    harness.Options{Provider: "claude-code", MaxBudgetUSD: 1.0})

// Or set it once for the whole agent.
cfg := agent.Config{HarnessConfig: &agent.HarnessConfig{Provider: "claude-code"}}