The 3-Core Agent Harness: Planner, Generator, Evaluator for Production AI Agents

Production AI agent systems thrive with a 3-core agent harness—Planner for high-level outlines, Generator for implementation, Evaluator for adversarial critique using graded rubrics—stripping 90% bloated framework overhead per Anthropic tests.¹ This leverages modern LLMs' 1M+ token windows and coherence for reliable, scalable outputs on long-horizon tasks.

You've likely tried agent frameworks that promise reliability but deliver cascading errors from micro-task sharding. Those assumptions fit older LLMs with short contexts and poor coherence, not Claude Opus 4.6. This harness ships product-level work like high-volume AI-generated PRs, letting you focus on primitives over complexity.

Anthropic's experiments, summarized by AI LABS, tested stripping frameworks layer by layer on long tasks.¹ Results showed only the Planner for product outlines, Generator for execution, and Evaluator for critique delivered gains. Complex staging in SpecKit or loops in GSD added token bloat and error drift without benefits.

Contrast traditional setups: BMAD shards PRDs into micro-tasks to handle context resets; GSD enforces rigid agent loops for weak reasoning. With 1M-token windows, LLMs now manage full product scopes autonomously—micro-sharding forces premature decisions that fail downstream.¹

Nate B. Jones's analysis of Claude's leaked code reinforces primitives over frameworks for scalability.² Agent Blueprint advises single-agent mastery before multi-agent scaling.³

To see it in action, here's a minimal YAML harness stub using Archon V3 style for a task-tracking app:

harness:
  planner:
    role: "Product Lead"
    goal: "Outline task-tracking app"
    tools: ["search"]
    rules: ["High-level only; flag risks; no code"]
    output: "Markdown: user stories, features, roadmap"
  generator:
    role: "Engineer"
    goal: "Implement planner outline"
    tools: ["git", "calc"]
    rules: ["Isolated worktree; commit artifacts"]
    output: "Code files + README"
  evaluator:
    role: "QA Adversary"
    goal: "Score vs rubric"
    tools: ["playwright"]
    rules: ["Assume flaws; weighted scores"]
    output: "JSON: scores, fixes"

Run via GitHub Actions: trigger on issue, parse YAML, invoke Claude sequentially. This beats npm installs—I've shipped PRs weekly this way. We'll detail roles, primitives, build steps, and trade-offs next.

Why Production Agent Systems Need a 3-Core Agent Harness

Ditch bloated agent frameworks—a 3-core agent harness with Planner, Generator, and Evaluator outperforms them by playing to LLM strengths like large contexts and autonomy. Anthropic's Claude Opus 4.6 tests show 90% of components in BMAD, GSD, and SpecKit are redundant overhead that propagates errors on long-horizon tasks.¹ High-level planning avoids flawed detailed specs, while separate evaluation enforces rigor.

Traditional frameworks compensate for outdated LLM limits: context resets demand sharding, weak coherence needs rigid loops. But 1M-token windows and improved reasoning make micro-tasking counterproductive—it forces premature decisions that cascade failures.

Anthropic's experiments, summarized by AI LABS, tested stripping frameworks layer by layer. Results? Only the planner for product outlines, generator for execution, and evaluator for critique yielded gains. Complex staging in SpecKit or GSD loops adds no value; it bloats token use and invites drift.¹

Nate B. Jones's analysis of Claude's leaked code echoes this: primitives beat frameworks for scalability.² Agent Blueprint stresses single-agent mastery first, scaling only for distinct skills.³

I've built agents both ways. Frameworks feel safe until production hits—then you're debugging orchestration bugs, not shipping features. The harness cuts that noise.

The Planner's Role in a 3-Core Agent Harness

In a 3-core agent harness, the Planner generates high-level product outlines, feature breakdowns, and user stories—not micro-tasks—enabling LLMs to autonomously discover optimal paths and avoid error cascades from over-specification. Anthropic's boundary-testing prompts prove Claude Opus 4.6 excels here, generating phased docs without diving into code.¹

Start prompts with Role + Goal + high-level deliverables. Here's a concrete example for a task-tracking app:

You are a product lead with 10+ years shipping SaaS.

Goal: Outline a task-tracking app for indie devs.

Deliverables:
- 5-10 user stories (As a [user], I want [feature] so [benefit])
- Key features prioritized by MVP
- Phased roadmap (Week 1: Core; Week 2: Polish)
- Risks and assumptions

Rules: Stay high-level—no code, tech stacks, or UI mocks. Flag unknowns.

Output: Markdown sections only.

Claude Opus 4.6 generates phased docs like this, iterating on creative paths humans might miss.¹

Avoid native "plan" modes—they fixate on implementation details too early. Archon V3 uses declarative YAML for living workflows, updating plans mid-run.⁴

Agent Blueprint's formula drives reliability: Role + Goal + Tools + Rules + Output.³ For Planner: Tools minimal (search only), Rules ("Stay high-level; flag risks"), Output (Markdown sections).

Benefits compound. LLMs outperform humans on detail synthesis—let them handle it post-outline. I've used this for 20+ newsletter outlines; it surfaces non-obvious features like "AI-suggested subtasks" I overlooked.

Contrast SpecKit: It stages detailed specs early, locking in assumptions that drift during generation.⁵ High-level planning iterates faster.

For code integration, pipe output to Generator via file:

claude --prompt planner_prompt.md --output planner_outline.md
git add planner_outline.md

This keeps plans as artifacts, versioned and reviewable. Scale to repos: Plan entire features from GitHub issues.

The Generator's Focused Role in the 3-Core Agent Harness

In a 3-core agent harness, the Generator executes solely on Planner outlines in isolated environments like Git worktrees, producing code, content, or artifacts while avoiding self-evaluation bias and memory bloat. It uses tools sparingly (search, calc) for clean, iterable outputs. Archon V3's Markdown commands make this reusable across tasks.⁴

Core loop: Think, tool if needed, observe, repeat—but single-purpose. No chit-chat; output to files for persistence.

Contrast multi-role agents: Combining generation and eval leads to overconfidence. Generators praise mediocre work; separation forces honesty.

Examples abound. For newsletters: Planner outlines sections, Generator drafts in Markdown. For code: Implement features in fresh worktrees, committing artifacts.

This ties to spec-centric flows like SDD or SpecKit—Generator translates living specs without drift.⁵ No shared memory; pass via files.

In practice, isolation prevents hallucinations from long contexts. I've generated 50+ PRs weekly this way—far beyond chat-based tinkering.

Why a Separate Evaluator Delivers Production Quality

A dedicated Evaluator in the 3-core agent harness scores outputs adversarially against graded rubrics—like UI axes (design: 25%, originality: 25%, craft: 25%, functionality: 25%)—iterating until standards hit and upgrading GSD's pass/fail to nuanced critique assuming bugs exist. Anthropic stresses holistic excellence over TDD alone.¹

Rubrics weight criteria explicitly. UI example: "Design: Modern, intuitive? Originality: Avoids gradients? Craft: Typography/spacing precise? Functionality: Playwright-tested?"

Why separate? Generators optimize for completion, not quality—they hallucinate strengths. Evaluator simulates users, probing edge cases.

Loop: Critique → Regenerate → Rescore until pass. Agent Blueprint pairs evaluator-optimizer for this.³

Examples scale to subjective work. UI grading rejects cookie-cutter designs; content rubrics check voice alignment.

Essential Primitives for Reliable 3-Core Agent Harnesses

Production 3-core agent harnesses require "boring" primitives like dual tool registries (207+ commands), tiered permissions (18 bash modules), JSON state persistence, token budgeting with projections, structured streaming, and verification. As detailed in Nate B. Jones's analysis of Claude's leaked code, these essentials harden demos into scalable systems handling crashes, controlling costs, and ensuring 24/7 operation.² Without them, you're prototyping, not producing.

• Dual tool registries (207+ commands)²
• Tiered permissions (18 bash modules)²
• JSON state persistence
• Token budgeting with projections
• Structured streaming
• Verification

Nate B. Jones details 12 keys from the Claude code leak: Registries filter runtime tools dynamically; permissions gate risks (built-in > plugins > user-defined).²

State Persistence: Full session JSON (messages, tokens, config) for crash recovery.

Example:

{
  "session": {
    "messages": [...],
    "tokens_used": 12500,
    "config": {"model": "claude-3.5-sonnet"}
  }
}

Save on every tool call; resume seamlessly.

Budgeting: Hard limits + projections. Pre-compute: "This task forecasts 50k input + 20k output tokens."

def project_tokens(prompt_len, steps=10):
    return prompt_len * 1.2 * steps  # Conservative multiplier
if project_tokens(len(planner_outline)) > 100000:
    abort("Budget exceeded")

I've seen major cost savings with budgeting alone on weekly PR batches.

Observability: Typed events/logs. Stream: {"event": "tool_call", "tool": "git", "result": "committed"}

Tool Registry: Metadata-driven:

tools:
  git:
    desc: "Git operations"
    perms: "built-in"
    args: ["commit", "push"]
  playwright:
    desc: "UI tests"
    perms: "plugin"

Permissions: State objects—no world access. permissions: {"bash": ["ls", "cat"], "deny": ["rm -rf"]}²

Verification: Guardrail tests post-output. Archon V3 adds pre/post-tool hooks:

hooks:
  pre-tool: "validate_args(tool, args)"
  post-tool: "verify_output_schema(result)"

Agent Typing: Modes like explore/plan/verify; permissions evolve with state.²

Dynamic pools swap tools mid-run. Skip these, long tasks fail frequently—primitives ensure 24/7 operation.

Building and Scaling Your 3-Core Agent Harness

Assemble a 3-core agent harness via YAML/DAGs (Archon V3), Claude teams, or SpecKit staging: Define each core with Role+Goal+Tools+Rules+Output, layer primitives, master single-agent first, then scale multi for skills.³⁴ GitHub Actions trigger workflows; minimal tools/memory.

Steps:

1. Planner Prompt: "Role: Product lead. Goal: Task. Tools: Search. Rules: High-level only. Output: Markdown outline."
2. Generator: "Role: Engineer. Goal: Implement outline. Tools: Git, calc. Rules: Isolated worktree. Output: Committed artifacts."
3. Evaluator: "Role: QA adversary. Goal: Score vs rubric. Tools: Playwright. Rules: Assume flaws. Output: Scores + fixes."

Add primitives: Token budgeter, JSON state.

Test on messy inputs. Ready starters: GSD + rubrics; Archon builtins (fix-issue, idea-to-PR).⁴

Scaling: Orchestrators route; parallelism via DAGs.

Harness over frameworks—I've shipped 10x faster.

Trade-offs, Misconceptions, and When to Skip Agents

The 3-core agent harness swaps framework "safety" for speed but requires primitive investment; it costs more upfront yet runs leaner long-term, with budgeting taming expenses. Misconceptions: Micro-tasks aren't needed (LLMs obsolete them); always multi-agent (master single first). Skip for deterministic chaining/routing—use Anthropic's 5 workflows.³

Trade-offs:

• Build Time: Primitives take days vs. framework npm install.
• Eval Subjectivity: Rubrics need tuning for creative work.
• Costs: Long tasks hit tokens—mitigate with projections.²

Risks: No permissions = demo, not product.² Frameworks aren't future-proof; LLMs evolve.

When to skip: Simple transforms? Chain prompts. Agents shine on open-ended horizons.

Open: Rubric standards? This works today—iterate your own.

Pick a stalled repo project. Strip any agent setup to these three roles using Role+Goal+Tools+Rules+Output. Add token budgeting as your first primitive. Run on one feature, measure output quality and costs before scaling—you'll ship faster than with frameworks.