Harness

from pydantic import BaseModel
from agentfield import Agent, HarnessConfig

class ReviewResult(BaseModel):
    findings: list[str]
    severity: str  # "low" | "medium" | "high"

# Defaults pinned on the agent — every .harness(...) call inherits them.
# No provider, no model: this runs on AForge with its own default model.
app = Agent(
    node_id="reviewer",
    harness_config=HarnessConfig(
        max_turns=12,
    ),
)

@app.reasoner()
async def review_diff(diff: str) -> dict:
    result = await app.harness(
        f"Review this diff. Be precise, no fluff.\n\n{diff}",
        schema=ReviewResult,
    )

    if result.is_error:
        return {"ok": False, "error": result.error_message}

    return {
        "ok": True,
        "review": result.parsed.model_dump(),
        "cost_usd": result.cost_usd,
        "num_turns": result.num_turns,
        "session_id": result.session_id,
    }

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

const ReviewResult = z.object({
  findings: z.array(z.string()),
  severity: z.enum(['low', 'medium', 'high']),
});

// No provider, no model: this runs on AForge with its own default model.
const harnessConfig: HarnessConfig = {
  maxTurns: 12,
};

const app = new Agent({ nodeId: 'reviewer', harnessConfig });

app.reasoner<{ diff: string }>('review_diff', async (ctx) => {
  const { diff } = ctx.input;
  const result = await app.harness(
    `Review this diff. Be precise, no fluff.\n\n${diff}`,
    { schema: ReviewResult },
  );

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

  return {
    ok: true,
    review: ReviewResult.parse(result.parsed),
    costUsd: result.costUsd,
    numTurns: result.numTurns,
    sessionId: result.sessionId,
  };
});

package main

import (
    "context"
    "fmt"

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

type ReviewResult struct {
    Findings []string `json:"findings"`
    Severity string   `json:"severity"`
}

func newReviewer() (*agent.Agent, error) {
    return agent.New(agent.Config{
        NodeID:  "reviewer",
        Version: "1.0.0",
        // No Provider, no Model: this runs on AForge with its own default model.
        HarnessConfig: &agent.HarnessConfig{
            MaxTurns: 12,
        },
    })
}

func reviewDiff(ctx context.Context, app *agent.Agent, diff string) (*ReviewResult, error) {
    var out ReviewResult
    schema, _ := harness.StructToJSONSchema(out)

    result, err := app.Harness(ctx,
        "Review this diff. Be precise, no fluff.\n\n"+diff,
        schema, &out,
        harness.Options{}, // empty — inherits HarnessConfig from the agent
    )
    if err != nil {
        return nil, err
    }
    if result.IsError {
        return nil, fmt.Errorf("harness: %s", result.ErrorMessage)
    }
    return &out, nil
}

result = await app.harness(prompt, schema=ReviewResult, provider="claude-code")

# Claude Code is also the provider that enforces a USD cost cap and a tool allowlist.
capped = await app.harness(
    prompt,
    schema=ReviewResult,
    provider="claude-code",
    permission_mode="plan",
    max_budget_usd=0.50,
    tools=["Read", "Grep", "Glob"],
)

const result = await app.harness(prompt, { schema: ReviewResult, provider: 'claude-code' });

// Claude Code is also the provider that enforces a USD cost cap and a tool allowlist.
const capped = await app.harness(prompt, {
  schema: ReviewResult,
  provider: 'claude-code',
  permissionMode: 'plan',
  maxBudgetUsd: 0.5,
  tools: ['Read', 'Grep', 'Glob'],
});

result, err := app.Harness(ctx, prompt, schema, &out,
    harness.Options{Provider: "claude-code"})

// Claude Code is also the provider that enforces a USD cost cap and a tool allowlist.
capped, err := app.Harness(ctx, prompt, schema, &out,
    harness.Options{
        Provider:       "claude-code",
        PermissionMode: "plan",
        MaxBudgetUSD:   0.50,
        Tools:          []string{"Read", "Grep", "Glob"},
    })

# Plan with Claude (careful reasoner), execute with Codex (fast implementer).
plan = await app.harness(prompt, provider="claude-code", permission_mode="plan", schema=ChangePlan)
edits = await app.harness(apply, provider="codex",       permission_mode="auto", schema=EditReport)

const plan  = await app.harness(prompt, { provider: 'claude-code', permissionMode: 'plan', schema: ChangePlan });
const edits = await app.harness(apply,  { provider: 'codex',       permissionMode: 'auto', schema: EditReport });

plan, _ := app.Harness(ctx, prompt, planSchema, &planOut,
    harness.Options{Provider: "claude-code", PermissionMode: "plan"})
edits, _ := app.Harness(ctx, apply, editSchema, &editOut,
    harness.Options{Provider: "codex", PermissionMode: "auto"})

async def hardened_harness(prompt: str, schema, **opts):
    for provider in ("aforge", "claude-code"):
        result = await app.harness(prompt, schema=schema, provider=provider, **opts)
        if not result.is_error and result.parsed is not None:
            return result
    raise RuntimeError(f"all providers failed: {result.error_message}")

async function hardenedHarness<T>(prompt: string, schema: T, opts: HarnessOptions = {}) {
  for (const provider of ['aforge', 'claude-code'] as const) {
    const r = await app.harness(prompt, { ...opts, provider, schema });
    if (!r.isError && r.parsed !== null) return r;
  }
  throw new Error('all providers failed');
}

for _, provider := range []string{"aforge", "claude-code"} {
    r, err := app.Harness(ctx, prompt, schema, dest,
        harness.Options{Provider: provider})
    if err == nil && !r.IsError {
        return r, nil
    }
}
return nil, errors.New("all providers failed")

runs = await asyncio.gather(*[
    app.harness(prompt, provider=p, schema=ImplResult, max_budget_usd=0.05)
    for p in ("claude-code", "codex", "opencode")
])

verdict = await app.harness(
    "Pick the best implementation. Score on correctness and minimality.\n\n"
    + format_runs(runs),
    provider="claude-code",
    schema=Verdict,
)
return runs[verdict.parsed.winner_index]

const runs = await Promise.all(
  (['claude-code', 'codex', 'opencode'] as const).map((p) =>
    app.harness(prompt, { provider: p, schema: ImplResult, maxBudgetUsd: 0.05 }),
  ),
);
const verdict = await app.harness(
  `Pick the best implementation.\n\n${formatRuns(runs)}`,
  { provider: 'claude-code', schema: Verdict },
);
return runs[verdict.parsed.winnerIndex];

var runs []*harness.Result
for _, p := range []string{"claude-code", "codex", "opencode"} {
    r, _ := app.Harness(ctx, prompt, implSchema, &implOut,
        harness.Options{Provider: p, MaxBudgetUSD: 0.05})
    runs = append(runs, r)
}
v, _ := app.Harness(ctx, judgePrompt(runs), verdictSchema, &verdict,
    harness.Options{Provider: "claude-code"})

for attempt in range(3):
    impl = await app.harness(prompt, provider="codex", schema=ImplResult)
    if impl.is_error:
        continue

    review = await app.harness(
        f"Find real bugs in this change:\n\n{impl.parsed.diff}",
        provider="claude-code",
        permission_mode="plan",
        schema=ReviewResult,
    )
    if review.parsed.severity in ("low", "medium"):
        return impl  # accepted

    prompt = f"Re-attempt. Previous reviewer findings:\n{review.parsed.findings}\n\n{prompt}"

for (let attempt = 0; attempt < 3; attempt++) {
  const impl = await app.harness(prompt, { provider: 'codex', schema: ImplResult });
  if (impl.isError) continue;

  const review = await app.harness(
    `Find real bugs in this change:\n\n${impl.parsed.diff}`,
    { provider: 'claude-code', permissionMode: 'plan', schema: ReviewResult },
  );
  if (review.parsed.severity !== 'high') return impl;
  prompt = `Re-attempt. Reviewer findings:\n${review.parsed.findings}\n\n${prompt}`;
}

for attempt := 0; attempt < 3; attempt++ {
    impl, _ := app.Harness(ctx, prompt, implSchema, &implOut,
        harness.Options{Provider: "codex"})
    if impl.IsError { continue }

    review, _ := app.Harness(ctx, reviewPrompt(implOut), reviewSchema, &reviewOut,
        harness.Options{Provider: "claude-code", PermissionMode: "plan"})
    if reviewOut.Severity != "high" { return implOut, nil }

    prompt = retryPrompt(reviewOut, prompt)
}