How to evaluate coding-agent sessions

Why the Whole Coding-Agent Session Matters

The goal is not only to catch a bad coding-agent session. It is to improve the agent and the software factory around it. You need to know where agents lose context, choose the wrong tool, repeat work, weaken tests, make unnecessary edits or stop before the task is actually complete. Those patterns show whether the next improvement belongs in the prompt, model, repository context, tool design, test suite or workflow.

A final diff cannot provide that evidence on its own. Coding-agent evaluation needs the prompt, commands, edits, tool results, errors and final response in one trace, followed by analysis across many sessions. Failproof AI was built for this workflow: it evaluates complete coding-agent sessions, finds recurring and previously unknown failure patterns, and gives teams the evidence they need to make agents more reliable, efficient and capable over time.

1. Connect the Coding Agent

Install Failproof AI in one line, then connect it to Cloud and wire the hooks for the coding agent you use. New sessions are captured without adding tracing calls throughout the agent code.

npm install -g failproofai

failproofai config --token <key>
failproofai policies --install

Failproof AI supports coding-agent harnesses including Claude Code, Codex, GitHub Copilot CLI, Cursor, OpenCode, Pi, Factory Droid and Devin. Give each agent and environment a stable name so production, staging and different agents remain separable in evaluations, queries, dashboards and audits.

2. Evaluate Outcomes and Behavior

Start with questions tied to real engineering failures. Use code-based evaluations when the answer can be read exactly from the trace. Use LLM-based evaluations when the check requires understanding the task, code change or surrounding context.

Keep the results separate. A session that completed the task but changed unrelated infrastructure should not average into one harmless-looking quality score. Each failure should lead back to the exact trace evidence that explains it.

Evaluations run in Failproof AI Cloud and appear with the session under Observe → evaluations. Re-evaluate an individual session, backfill recent sessions after adding a check, or aggregate results by agent and environment.

fp evals --since 24h --aggregate
fp evals --agent-id coding-agent --aggregate
fp --json evals --aggregate --env production

3. Find Failures You Did Not Write a Check For

Evaluations measure failure modes you already know to ask about. Audits look across session traces, evaluation results and policy decisions to find recurring behavior you may not have named yet. For a coding agent, an audit might reveal that it repeatedly edits generated files, abandons tasks after authentication errors or changes tests whenever an implementation becomes difficult.

Create an audit with a goal such as “find coding sessions that report success without enough evidence.” Set the agent, environment and time window, then run it on a cadence. Each finding contains analysis, severity, affected sessions, trace evidence and a recommended fix.

fp audits list
fp audits findings --status open --limit 20

Open several affected sessions before changing the agent. The same failed score can come from a missing tool, an ambiguous task, a bad model choice, insufficient repository context or a prompt that rewards finishing over verifying. The evidence tells you which part to fix.

4. Track the Behavior and Alert the Owner

Use Analyze → Queries for questions that cut across sessions, then save useful queries to a dashboard. Compare failure rates by agent, environment or time period; count sessions with tool errors; or list the repositories where verification most often goes missing.

fp agent ask "Which production coding agents skipped verification most often this week?"
fp query run <query-id>

Create alerts for evaluation-score drops, compound conditions, metric thresholds or saved SQL conditions. Route them to email, Slack, a webhook or the Failproof dashboard, and assign the issue to the person who owns the prompt, tool or workflow.

5. Fix the Cause and Verify the Recovery

A finding should lead to a concrete change: clarify the task template, expose a missing tool, improve repository context, change the model, require CI evidence or narrow the workflow. Keep the evaluation and audit running after the change. A sustained score recovery and the disappearance of the original pattern are stronger evidence than one successful replay.

For a known high-risk action, Failproof AI can close the loop with a policy. Its maintained coding-agent pack includes protections for pushes to the main branch, environment files, sudo and curl-pipe-shell commands, plus secret redaction. Custom policies can enforce repository-specific boundaries.

Do not turn every failed evaluation into a block. Use a policy only when the action is unambiguously unsafe, backtest it against past sessions, run it in observe mode and review false positives before enforcement. Keep the evaluation after enforcement to see whether the agent learned a better path or simply keeps attempting the denied action.

What a Useful Coding-Agent Evaluation Setup Looks Like

• Complete traces: prompts, tool calls, tool results, edits, errors and the final response are connected in one session.
• Known checks: code-based and LLM-based evaluations cover failures the team already understands.
• Automatic discovery: recurring failures are grouped into findings instead of waiting for manual review.
• Operational ownership: dashboards show trends, alerts reach the right channel and issues have an assignee.
• Verified fixes: the same evaluations and audits prove whether a change worked.
• Selective policies: only tested, high-confidence rules interrupt an action before it runs.

If one developer reviews every diff and CI gates every merge, that may be enough for a small workload. Session evaluation becomes valuable when agents work unattended, run across several repositories or produce enough sessions that nobody can inspect each trajectory by hand.