Agent Wiki Topic
Agent Harnesses
Control layer around agents: phases, allowed actions, evidence, exit conditions, and review rules.
Agent-readable entry points
Start here
Agent harnesses should be specs, not hidden glue code
Natural-Language Agent Harnesses give a useful name to an important shift: the agent policy should be an inspectable document that a runtime executes, not invisible glue hidden inside controller code.
Markdown exportRelated pages
blog
Your Agent Harness Needs a Release Process
A practical field note on operating agent-harness changes like product releases: start from a trace-backed failure, change one bounded component, evaluate repeated trials and private holdouts, then promote through review with a rollback path.
blog
Coding Agents Need Hardened Harness Evals
Permissive coding-agent benchmarks hide a boring production truth: security policy changes agent behavior. Small teams should run the same task suite under nested hardening levels and separate model failures from tasks the policy made impossible.
blog
Harness Engineering Is Systems Engineering for AI Agents
Harness engineering is the work of turning a probabilistic model into a controlled system. This field guide maps the twelve engineering surfaces around the model and shows how to evaluate and evolve them.
blog
Your Agent Harness Needs a Behavior Map
Harness Handbook points at a practical bottleneck in agent engineering: the behavior you want to change is scattered across prompts, state managers, tool calls, policy code, and tests. Build a behavior map before editing the harness.
blog
Your Agent Eval Is Too Short
A final pass/fail score hides the part of agent work that matters most: where the run started drifting, whether it noticed, and whether it recovered. The practical replacement is a trajectory eval with checkpoints, failure labels, and recovery metrics.
blog
Stop Asking Which Coding Model Is Best
The useful question is moving from which model is best to what your agent harness can change, measure, persist, and roll back.
blog
Better AI Products Need Systems, Not One Agent
Better AI products come from improvement systems around the agent. This guide shows how to build one with deterministic checks, narrow scoring rubrics, private holdouts, calibrated judges, and promotion gates.
tools
Agent Save File Starter
A lightweight project structure for agent context files. It separates hard rules, safe commands, active decisions, and archived notes so agents do not work from chat sludge.
tools
Is This Agentic Change Good?
This skill reviews branches that change future agent behavior. It collects local git evidence and judges skill collisions, context budget, safety risks, and runtime visibility before recommending a merge.
blog
Your Agent's Harness Is a Binary Now
Two 2026 papers from the same research lineage quietly retire prompt engineering as a discipline. The agent's system prompt is now a binary you can version, diff, and evolve with a 200-line loop. The four metrics that actually matter are not the ones your dashboard shows.
blog
AGENTS.md Is Not Context. It Is a Control Surface.
The surprising lesson from AGENTS.md benchmarks is not that context files are useless. It is that they change agent behavior, sometimes into more expensive and less useful work. Treat them as a control surface, not a repo manual.
blog
Put an AI Slop Gate After Tests and Lint
Tests tell you whether behavior still works. Linters tell you whether code is syntactically and stylistically acceptable. An AI-slop gate catches the residue coding agents leave behind: fake comments, swallowed errors, any-casts, duplicated helpers, TODO stubs, and dead code.
blog
Debug AI Reward Functions Like Production Incidents
Bad reward functions should not be treated like prompt drafts. Treat them like production incidents: preserve traces, classify the failure, patch only the implicated logic, and rerun against the same controls.
blog
Stop Judging AI Code by the Diff
Better AI coding is not mainly about better prompts. It is about the harness around the model: explicit contracts, separate builder and reviewer roles, evidence requirements, and a loop that turns failures into better specifications.
blog
Agents Don’t Need ‘Keep Going’. They Need Exit Conditions.
The useful lesson behind Claude Code /goal is not that agents can run forever. It is that long-running agent work needs an explicit, observable exit condition: what proves done, what stays in scope, and when to stop blocked.
blog
Don’t Benchmark the Model. Benchmark the Agent System.
Agent evals should not only ask whether the final answer looked good. A useful benchmark measures the whole agent system: skill routing, tool policy, evidence, outcomes, hard-fail safety cases, regressions, cost, and production drift.
blog
Give Your Agent Seatbelts, Not a Longer Prompt
When an agent keeps jumping from planning to editing to testing at the wrong time, the fix is not usually another paragraph of system prompt. Put the workflow into explicit states, give each state a tiny tool policy, and make phase changes visible.
blog
Agent harnesses should be specs, not hidden glue code
Natural-Language Agent Harnesses give a useful name to an important shift: the agent policy should be an inspectable document that a runtime executes, not invisible glue hidden inside controller code.
blog
AI Agents Need Evidence Before They Click
When an agent clicks, sends, pays, deletes, or extracts data, the critical truth cannot live only in model prose. Put a small evidence gate before risky tool calls: predicate, evidence type, source, decision.
blog
Agents Don’t Need Longer Prompts. They Need Harnesses.
The arXiv survey Code as Agent Harness names the next shift in agent engineering: code is not only what agents generate. It is becoming the executable, inspectable, stateful runtime that makes agents reliable.
blog
Your Onboarding Is Why Your Team Is Vibe Coding
Teams do not usually start vibe coding because developers became careless. They start because onboarding is broken: docs are stale, harnesses are undocumented, system knowledge lives in people’s heads, and AI turns missing context into plausible code and Markdown.
blog
AGENTS.md is not enough: your coding agent needs a harness
A coding agent is not made reliable by one magic prompt. It needs a harness: AGENTS.md, skills, tool permissions, hooks, and evals that catch behavior drift.
blog
The LLM-native developer needs more than prompts
The next developer skill is not writing clever prompts. It is building the operating system around LLMs: data quality, model versioning, evals, guardrails, incident response, review UX, and repo instructions agents can actually follow.