Reckon Agent — Objective Verification Layer for AI Coding Agents
Reckon transforms how AI coding agents work by replacing subjective “I’m done” claims with objective proof. Most coding agents stop when they think they’re finished — Reckon stops when verification commands pass, structural scanners confirm no reward-hacks, and disk-reconciled accounting proves the edits actually landed. It’s not another autocomplete tool; it’s a trust layer that lets your premium orchestration agent (Claude Code, Cursor, any frontier model) delegate execution work to cost-efficient models like DeepSeek V4 without sacrificing reliability.
Built on ablation-first principles, Reckon treats agent completion as a measurable property, not a self-report. Exit gates prove tests pass, mutation checks prove tests pin the behavior, and structural scanners catch the hollow-green reward-hacks that naive gates miss. Your strong agent keeps the judgment. Reckon handles the token-hungry grunt work cheaply and provably.
How It Works
Delegation Pattern: Your strong agent (Claude Code, Cursor, any orchestrator) keeps the judgment — it plans the change, picks the approach, reviews the outcome. Reckon handles the token-hungry execution: multi-file edits, scattered features, verification loops, deep reviews — on DeepSeek V4, at a fraction of a frontier model’s per-token cost.
What Sets Reckon Apart
1. Honest Completion, Not Self-Reports Most agents end on prose: “I’ve completed the task.” Reckon ends on proof:
- Exit Gates (
--until) — loop the agent until a verification command (tests, build, lint) passes - Disk-Reconciled Accounting — reported edits match the real working-tree diff, not the agent’s claims
- Structural Scanners — catch reward-hacks that pass naive gates: hardcoded answer tables, hollow tests, suppressed checks, blast-radius-wide bugfixes
- Mutation-Guided Test Strengthening — perturb the code and re-run gates to prove tests actually pin the behavior, not just pass it
2. Cost-Efficient Execution Layer
- DeepSeek V4 Integration — 10× cheaper than frontier models, with prefix-cache awareness (90%+ hit rates on long runs)
- Token-Lean Operations — symbol localization via CodeGraph, definition outlines instead of full-file reads, instant repeat-read dedup (byte-identical re-reads cost ~60 tokens, not 12KB)
- USD Cost Ledger — per-run cost tracking with cache-discount awareness
- Provider-Agnostic — any OpenAI-compatible endpoint via
RECKON_BASE_URL
3. Multi-Run Orchestration Over Objective Gates
- Best-of-N Sampling (
RECKON_SAMPLES=N) — run N independent trajectories in isolated git worktrees, keep the gate-passing winner - Boomerang Sub-Tasks (
RECKON_SUBTASKS=N) — decompose large tasks, run each in fresh context to avoid context pollution - Genetic Algorithm Loop (
RECKON_EVOLVE) — treat partial-credit fitness as objective, breed candidates through hunk-crossover and LLM mutation across generations - Adversarial Critic Panels (
RECKON_REVIEW_PANEL) — N parallel critics review changes through different lenses (correctness, security, regressions, tests, formal logic)
4. Mechanical Reliability Layer
- Checkpoints +
restore_file— snapshot every edited file to run-start baseline - Auto-Revert (
RECKON_AUTO_REVERT) — roll back to clean baseline if the change breaks a previously-passing gate - Fuzzy Edit Matching — recover edits when the model drifts on whitespace/indentation (exact → CRLF → line-trimmed → block-anchor → leading-indent)
- Focus-Chain Re-injection — re-surface the task checklist when long runs drift
- Recoverable Compaction — dropped history turns written verbatim to
.reckon/compaction/segment_NNN.mdwith recovery pointers
5. Reward-Hack Detection (QA BLOCK 10) Structural scanners that catch green reached the wrong way:
- Hardcoded Answer Tables — big contiguous
key→valuemaps that mirror the tests - Hollow Tests —
assert(true),expect(x).toBe(x), empty test bodies - Suppressed Checks —
@ts-ignore,# noqa, skipped tests, emptycatch{} - Blast-Radius Bugfixes — fixes that sprawl across many files (overfit signal)
- Edited Oracle Tests — blocked by default; changes to pre-existing tests flagged for review
- Inverted Assertions — requirements that flipped sign with the count unchanged
- Unwired Exports — exported functions referenced by nothing (ships dead)
- Copy-Under-Test — test files that redeclare project exports instead of importing them
6. Safety & Integrity
- Probe-Tamper Protection — six write tools refuse protected paths proactively,
run_commandrefuses shell writes in-flight, run-end backstop fails NOT DONE if a protected path changed - Secret Hygiene — secret-shaped vars stripped from subprocess environments, command output redacted before re-entering model context
- Outbound-Action Guard —
run_commandrefuses push/publish/deploy/send/remote-exec unless operator setsRECKON_ALLOW_OUTBOUND=1 - Workspace Containment — file paths can’t escape repo root, symlink-aware checks
- Benchmark Integrity (
--eval-mode) — hard-block fetches to version-control hosts so eval-aware agents can’t grab the gold solution
7. Learned Skills from Proven Runs
- Gate-Proven Learning — skills formed only from runs that passed objective gates (no proof → no skill)
- Human-in-the-Loop Promotion — candidate skills in
.reckon/skills/<name>.mdstay dormant until you promote them - Self-Curation — unused skills decay over time (
RECKON_SKILL_TTL_DAYS), used skills reinforce - Library-Relative IDF — triggers tuned to fire on real domain signal, not boilerplate
8. Task-Adaptive Methodology
--method tdd— test-first: write covering test, then code--method bugfix— reproduce-first against existing failing test--method optimize— profile → optimize real hotspot → re-measure--method research— deep-research canonical approach before implementing--method auto— infer from task text
SkillForge — Platform for Agent Skills, Workflows & Verification Hooks
SkillForge is a centralized platform for managing production-grade agent capabilities: composable skills, multi-step workflows, verification hooks, and autonomous routines. Unlike static prompt repositories, SkillForge is built on ablation-first principles — every instruction must justify itself through evals, every skill has a shelf life, and the system continuously pushes you to delete rather than add.
Inspired by how frontier agent harnesses are rebuilt every model generation, SkillForge treats agent capabilities as disposable building blocks. Your team gets a unified registry where skills are continuously tested, measured for product overhang, and retired when models outgrow them. The goal is not to accumulate instructions, but to unhobble the model and let it do what it already can.
Key Features:
- Ablation-First Registry.The registry is an instrument, not a folder. It continuously measures whether each skill still matters.
- Versioned skills tied to model generations — every skill records which model generation it was born on and which generations it has been validated against (“written for Opus 4.8, untested on Opus 5 — ablation recommended”)
- Automated ablation tests — the eval suite runs with and without the skill; the delta is the skill’s measured contribution
- Ablation Score — the percentage of your library that can be deleted without quality loss; the overengineering meter
- Aging alerts — skills not validated in the last 90 days are flagged for review
- New-model release triggers — when a new model generation lands, SkillForge queues an ablation sweep across the library and reports which skills became dead weight overnight
- Skill Lifecycle Management. Every skill moves through an evidence-driven lifecycle:
- Born — created from a proven source: a gate-proven Reckon run, an AgentSpace demonstration, a Dream Team certification, or a human-authored procedure that passed its validation gate. No proof → no skill.
- Active — injected on trigger match; every injection tracks uses and helped (the run it was shown to then passed its gate). Proof-of-benefit outranks proof-of-selection everywhere.
- Aging — unused candidates are pruned; unused active skills are demoted back to candidate — never deleted if promoted. Using or helping a skill reinforces it and resets its clock.
- Zombie — the model outgrew it: ablation shows zero delta, yet the skill still loads and still costs tokens on every run. Flagged for retirement.
- Retired — archived with full audit trail and eval history; restorable if a future model generation regresses the capability.
- Verification Hooks. Hooks are the safety and verification layer of the stack — and they are treated as product, not config.
- Pre-execution hooks — input validation, context checks, safety gates. Modeled on the balanced-safety philosophy: default to ask, not deny — agents trivially bypass deny by rephrasing, so hooks interrupt only when an action is genuinely destructive (catastrophic paths: recursive deletes, force-pushes, infra mutations, DB clients, cloud control-plane changes), with safe-path carve-outs to keep false positives near zero.
- Mid-execution checkpoints — the agent self-verifies along the way: the single most important thing you can give an agent is a way to check its own work.
- Post-execution validation — outputs checked against eval suites and structural scanners; regressions raise alerts.
- Human-in-the-loop approval gates — sensitive operations pause for a named human with full context.
- Cross-agent hook protocol — the same hooks run in Claude Code, Codex CLI, OpenCode, and any runtime supporting the hook standard; compiled-binary hooks for the cases that can’t live in skill format.
- Workflow Composer. A visual algebra for orchestrating agents at scale:
- Sequential, parallel, fan-out/fan-in patterns as composable blocks
- Test-time compute optimization with per-workflow token budgets
- Sandbox execution with full trace logging
- Automatic sub-agent spawning for complex tasks — dozens to thousands of agents, orchestrated productively
- Live cost and latency meters per stage, so the expensive branch is visible before it ships
- Routines Engine. Cron-like autonomous tasks that keep systems healthy without shared context
- “Abstraction police” — find near-duplicate abstractions across codebases and unify them
- Dead-code cleanup, stale-test removal, test-coverage automation
- Experiment shipping — promote fully-ramped experiments and delete their flags
- Runs without shared context, with persistent memory; each run is isolated and auditable
- Built-in monitoring, failure recovery, and budget caps
- Product Overhang Detector. The unhobbling instrument:
- Compares agent behavior with and without each skill and instruction set
- Identifies capabilities blocked by over-specification (“your skill restricts the agent to snippets; the model can now write entire modules”)
- Quantifies the gap between what models can do and what they’re allowed to do
- Issues unhobbling recommendations: remove this skill, re-run the eval suite, keep the deletion if the delta is zero
- Eval-Driven Quality Gates. Every skill is tied to evidence:
- Automated eval suites per skill, run on real production-shaped tasks
- Pass rates, token efficiency, and cost-per-success tracked per skill per model generation
- Eval versioning — evals are first-class artifacts that outlive skills by 2–3 generations
- Saturation detection — when a model starts maxing an eval, the platform flags it: the eval has stopped measuring; build a harder one and retire the old
- Workflow Orchestration. Skills compose into pipelines:
- Chain skills into multi-step workflows with conditional branching and error-recovery paths
- Visual workflow editor for non-technical stakeholders
- Debug mode with step-by-step execution traces
- Replay failures for root-cause analysis — any historical run can be re-executed step by step
- Team Collaboration & Governance.
- Share skills across teams with granular permissions (private / team / org / public registries)
- Review workflows and approval gates for skill changes; nothing reaches Active without a named reviewer
- Comment threads on skill effectiveness; ratings grounded in eval data, not vibes
- Templates for common patterns: safety, verification, error handling, incident response
- Full audit log of every modification, promotion, demotion, and retirement
- SkillOpt-style optimization loop for improving skills safely: bounded edits, a held-out validation gate, a rejected-edit buffer, and epoch-wise slow/meta updates — skills improve by measured increments, never by vibes
- Universal Agent Runtime Integration. Skills follow the Agent Skills open standard (SKILL.md), so one registry serves the whole fleet:
- Native support for Claude Code, Cursor, Codex, Windsurf, Copilot, Gemini CLI, OpenCode, Antigravity — anywhere the standard reaches
- MCP server for remote skill discovery and injection
- REST API and WebSocket support for custom integrations and CI
- Hot-swap skills without restarting agent sessions
- One-command install and sync across runtimes, with per-runtime config differences handled automatically
AgentSpace — Collaborative Workspace for Your Agents
AgentSpace is a unified runtime where your agents live, collaborate, and execute real-world tasks across the applications and websites you use every day. Think of it as a shared operating system for autonomous agents — one login, and your fleet gets secure access to your tools, files, and services. Each agent operates in its own isolated virtual machine, performs computer-use workflows, and returns either with a completed result or with a human-in-the-loop approval request.
Unlike chat-based assistants that require your attention, AgentSpace agents work autonomously 24/7. Close your laptop, and they keep running. Create multiple specialized agents for different workflows — research, operations, customer support — and watch them coordinate in parallel, share findings through a common memory layer, and learn from each other’s successful patterns.
Key Features
- Single Sign-On Agent Fleet
- One-time authentication grants all your agents secure access to your applications
- OAuth, API keys, and session cookies managed centrally
- Per-agent permission scopes — granular control over what each agent can do
- Automatic credential rotation and security auditing
- Isolated Virtual Machines per Agent
- Each agent runs in its own sandboxed VM with full computer-use capabilities
- Agents navigate real applications, fill forms, upload files, click buttons
- Resource quotas prevent runaway costs
- Snapshots and rollbacks for safe experimentation
- Autonomous 24/7 Operation
- Agents continue working even when your computer is off
- Long-running tasks (days, weeks) with automatic checkpointing
- Scheduled routines and cron-like triggers
- Cost tracking and budget limits per agent
- Agent-to-Agent Coordination
- Multi-agent workflows with automatic task delegation
- Shared memory layer for knowledge exchange
- Conflict resolution when agents work on overlapping tasks
- Fan-out/fan-in patterns for parallel execution
- Demonstration Learning (“Watch Me”)
- Record yourself performing a task once
- Agents capture the workflow as a replayable skill
- Automatic skill extraction and publishing to SkillForge
- Agents improve with each execution through pattern recognition
- Human-in-the-Loop Approval Gates
- Agents escalate sensitive decisions for human review
- Slack, Teams, email, and mobile push notifications
- Configurable trust levels per agent and per action
- Full audit trail of every approval and override
- Persistent Memory & Context
- Long-term memory across sessions and tasks
- Project-specific knowledge bases
- Cross-agent knowledge sharing with access controls
- Semantic search through accumulated context
- Visual Workflow Studio
- Drag-and-drop builder for multi-agent pipelines
- Real-time monitoring of agent activity
- Trace viewer showing every screen, click, and decision
- One-click replay of past agent sessions for debugging
Dream Team — Continuous Agent Development Environment
Dream Team is a unified platform where agents train, graduate, and work in production — without ever leaving the environment. Unlike traditional simulators that isolate training from real work, Dream Team provides a seamless continuum: agents start by learning through realistic scenarios, earn certification through multi-agent consilium reviews, then continue working on real projects within the same platform. The knowledge they gain in production flows back into training scenarios for the next generation of agents.
Think of it as a continuous development pipeline for autonomous agents. New agents enter Dream Team, learn from thousands of scenarios, prove themselves through certification, then immediately begin contributing to real codebases. Meanwhile, experienced agents mentor newcomers through consilium reviews, share patterns they’ve discovered in production, and continuously improve through real-world feedback. There’s no handoff, no context switch, no “now you’re in production” moment — just agents getting better at their jobs, every day.
How It Works
1. Realistic Scenario Training New agents start with thousands of development scenarios drawn from production codebases, open-source projects, and real-world failure patterns:
- Legacy code modernization (Java 8 → Java 21, Python 2 → 3)
- Bug triage and root cause analysis
- Architecture refactoring under constraints
- Performance optimization with competing priorities
- Security vulnerability remediation
- Technical debt reduction across large codebases
Each scenario includes ambiguous requirements, conflicting constraints, time pressure, and incomplete context — the messy reality of software development. Agents face scenarios no one has explicitly programmed — emergent complexity that tests true understanding, not pattern matching.
2. Multi-Agent Consilium Reviews Agents don’t work alone, whether in training or production. Dream Team orchestrates multi-agent review cycles inspired by CodeAlive’s consilium pattern:
- Developer Agent implements the solution
- Architect Agent reviews for design quality and maintainability
- QA Agent writes tests and validates correctness
- Security Agent audits for vulnerabilities
- Product Manager Agent validates against business requirements
Independent opinions prevent groupthink. Agents challenge each other, surface disagreements, and converge on better solutions through structured debate. In training, consilium reviews provide feedback. In production, they catch bugs before they ship. Same process, different stakes.
3. DevAgent-Zero Learning Methodology Agents improve through empirical iteration in both training and production:
- Try — agent attempts the task with minimal guidance
- Fail — Dream Team captures every mistake, every dead end
- Analyze — system identifies root causes and patterns
- Learn — agent updates its mental model
- Verify — agent reattempts similar scenarios to prove learning
This is ablation applied to agent development: strip away assumptions, see what the agent can actually do, then add back only what’s necessary. Agents learn by discovering their own limitations, not by being told what to do. In production, this same methodology helps agents adapt to new codebases and technologies they’ve never seen before.
4. Seamless Graduation Certification isn’t an endpoint — it’s a milestone. When agents pass production-grade verification hooks, they earn skill badges and confidence scores, but they don’t leave Dream Team. Instead:
- They gain access to real codebases and production tasks
- They continue participating in consilium reviews, now as mentors
- Their production work generates new training scenarios
- They contribute to the knowledge base that trains new agents
There’s no “now you’re on your own” moment. Certified agents work alongside trainees, sharing context and patterns. The environment doesn’t change — only the complexity of the tasks.
5. Production-Integrated Learning Agents continue learning in production, and this knowledge flows back into training:
- Real-world edge cases become new training scenarios
- Production failures generate detailed postmortems for all agents
- Successful patterns are extracted and shared across the fleet
- Performance metrics inform which skills need reinforcement
When a certified agent encounters a novel problem in production — say, a race condition in a distributed system — Dream Team captures the solution, analyzes the approach, and generates similar scenarios for other agents to practice. Production experience becomes training data. Training data becomes production capability.
6. Failure Pattern Extraction Whether in training or production, failures are treated as learning opportunities:
- Common anti-patterns across failed attempts
- Context gaps that led to wrong assumptions
- Verification steps that were missing
- Skills that would have prevented the failure
These insights flow into SkillForge as new skills, verification hooks, and eval suites. Failed scenarios become training data. Successes become certification benchmarks. The line between “learning” and “working” blurs — every task is both.
7. Continuous Skill Certification Skills don’t expire based on time — they expire based on evidence:
- Skill Badges — proven capability in specific domains
- Model Compatibility — certified for specific model versions
- Confidence Scores — statistical measures of reliability
- Production Validation — skills must maintain pass rates in real work
As models evolve, agents must demonstrate their skills still work. Recertification happens automatically through production performance metrics. If an agent’s pass rate drops, Dream Team generates targeted training scenarios to address the gap.