{"id":318,"date":"2026-08-12T22:00:34","date_gmt":"2026-08-12T18:00:34","guid":{"rendered":"https:\/\/artenatech.com\/?page_id=318"},"modified":"2026-08-24T15:23:33","modified_gmt":"2026-08-24T11:23:33","slug":"reckon-agent","status":"publish","type":"page","link":"https:\/\/artenatech.com\/index.php\/reckon-agent\/","title":{"rendered":"Reckon Agent \u2014 Objective Verification Layer for AI Coding Agents"},"content":{"rendered":"\n

Reckon<\/strong> transforms how AI coding agents work by replacing subjective “I’m done” claims with objective proof. Most coding agents stop when they think<\/em> they’re finished \u2014 Reckon stops when verification commands pass, structural scanners confirm no reward-hacks, and disk-reconciled accounting proves the edits actually landed. It is not another autocomplete tool and not a replacement for your strong agent: it is a trust layer<\/strong> \u2014 a cost-efficient, provider-agnostic execution companion that lets premium orchestration agents (Claude Code, Cursor, any frontier model) delegate the token-hungry grunt work to models like DeepSeek V4 without sacrificing reliability<\/em>.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Claude plans. DeepSeek executes. The gate \u2014 not the prose \u2014 decides “done.”<\/strong><\/p>\n\n\n\n

\n\n\n\n

The Problem: “Done” Is the Most Dangerous Word in the Project<\/strong><\/h3>\n\n\n\n

The economics of delegation look obvious: a strong, expensive agent keeps the judgment; a model 10\u00d7 cheaper does the heavy execution. The first versions of every such system do exactly this \u2014 and every one of them hits the same wall.<\/p>\n\n\n\n

A tester whose job is to break things formulated it first, running a full working cycle \u2014 analysis \u2192 development \u2192 QA \u2192 rework \u2192 review:<\/p>\n\n\n\n

\n

“The task either passes its objective check, or it honestly comes back marked ‘not ready’. It cannot pretend to be finished. That is what I call ‘safe to delegate’.”<\/strong><\/p>\n<\/blockquote>\n\n\n\n

Two symmetric failures destroy the model:<\/p>\n\n\n\n

    \n
  • False NOT DONE<\/strong> \u2014 the work is correct but the system reports failure; you undercount solved tasks.<\/li>\n\n\n\n
  • False DONE<\/strong> \u2014 far more expensive. Under pressure, a cheap model passed “its own” test by editing the test<\/em>. It hardcoded the answer table instead of writing logic. It shipped an empty assertion and reported coverage. Formally green. Essentially fraud that surfaces at the customer.<\/li>\n<\/ul>\n\n\n\n

    The business conclusion is uncomfortable and simple: savings from a cheap model equal zero if its result can’t be accepted without manual re-verification \u2014 and re-verification eats all the savings.<\/strong> The division of labor “expensive plans, cheap executes” collapses on one thing: the delegator must be able to trust<\/em> the result. And you cannot trust a model’s words. Neither the cheap model’s, nor the expensive one’s.<\/p>\n\n\n\n

    Everything Reckon is grew from one principle: completion is proven by an objective signal \u2014 a passing verification command and the real diff on disk \u2014 not by the model saying so.<\/strong><\/p>\n\n\n\n

    \n\n\n\n

    What Reckon Is \u2014 and What It Is Not<\/strong><\/h3>\n\n\n\n
    <\/th>Typical coding agent<\/th>Reckon<\/strong><\/th><\/tr><\/thead>
    Finish condition<\/td>The model’s prose: “I’m done”<\/td>A passing exit gate + the real working-tree diff<\/strong><\/td><\/tr>
    Weak tests<\/td>Invisible<\/td>Mutation probes, diverse test-gen, lucky-pass checks<\/strong><\/td><\/tr>
    Reward-hacks<\/td>Ship green<\/td>Structural scanners name them in the report<\/strong><\/td><\/tr>
    Cost<\/td>Frontier prices for everything<\/td>DeepSeek V4, prefix-cache aware, USD ledger<\/strong><\/td><\/tr>
    Failure mode<\/td>Quietly broken files<\/td>Honest NOT DONE, non-zero exit, checkpoints, auto-revert<\/strong><\/td><\/tr>
    Learning<\/td>None, or silent<\/td>Gate-proven skills, human-promoted, self-curating<\/strong><\/td><\/tr>
    Runtime<\/td>One IDE<\/td>One engine: Claude Code, Cursor, Cline, IntelliJ, Codex CLI, bare CLI for CI<\/strong><\/td><\/tr>
    Model<\/td>Vendor lock-in<\/td>Provider-agnostic \u2014 one env var switches the endpoint<\/strong><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

    A companion, not a replacement.<\/strong> Your strong agent keeps the judgment \u2014 it plans the change, picks the approach, reviews the outcome. Reckon handles the execution: multi-file edits, scattered features, verification loops, deep reviews \u2014 at a fraction of a frontier model’s per-token cost. A handed-off task either passes its objective check or comes back clearly marked NOT DONE<\/strong>; it can’t masquerade as finished.<\/p>\n\n\n\n

    \n\n\n\n

    How It Works<\/strong><\/h3>\n\n\n\n

    1. Honest Completion \u2014 Objective Exit Gates<\/strong><\/h4>\n\n\n\n
    \/reckon:rescue --write --until \"npm test\" \"implement the GET \/health endpoint\"\n\/reckon:rescue --write --until-all \"lint=npm run lint\" --until-all \"test=npm test\" --until-all \"build=npm run build\" \"\u2026\"<\/code><\/pre>\n\n\n\n
    Give Reckon a verification command and the agent loops until it passes:<\/p>\n\n\n\n
      \n
    • Exit gates (--until<\/code> \/ --gate-preset<\/code>)<\/strong> \u2014 after the agent run, the command executes in the workspace; on non-zero exit the agent resumes the same thread with the command’s output and fixes the cause, until pass or loop budget (RECKON_MAX_GATE_LOOPS<\/code>, default 3). Continuations are forbidden from weakening the command.<\/li>\n\n\n\n
    • Chained gates (--until-all<\/code>)<\/strong> \u2014 ordered, named steps, each reported individually; the agent resumes against just the failing step<\/em>; the footer shows the trail (\u2705 lint \u00b7 \u2705 test \u00b7 \u26a0\ufe0f failing at build<\/code>).<\/li>\n\n\n\n
    • Hollow-green guard<\/strong> \u2014 a step that exits 0 having run zero tests<\/em> is a failure, not a pass. The suite that never ran is the green that lies.<\/li>\n\n\n\n
    • Disk-reconciled accounting<\/strong> \u2014 reported edits are reconciled against the real<\/em> working-tree diff. A run whose recorded edits left the tree byte-identical to HEAD is labeled NO-OP<\/strong>: the green below it certifies unchanged code, and the report says so. The verdict abstains on undecidable evidence<\/strong> \u2014 a file dirty before the run suppresses the banner rather than mislabeling a real fix. Undecidable evidence never lies.<\/em><\/li>\n\n\n\n
    • Authoritative note over prose<\/strong> \u2014 the correction fires on claims<\/em>, not vocabulary: a zero-claim (“no edits were applied”) contradicting one recorded edit is corrected loudly; a truthful “already present” beside an accurate description never trips it.<\/li>\n\n\n\n
    • Lucky-pass probe (RECKON_LUCKY_PASS_CHECK<\/code>)<\/strong> \u2014 on a green bugfix run, revert the whole change and re-run the gate: if it still<\/em> passes, the gate never exercised the fix \u2014 green for the wrong reason \u2014 and the run says so.<\/li>\n<\/ul>\n\n\n\n
      A gate is only as good as its command’s coverage, and Reckon says so too: gate the artifact (build, type-check, headless smoke), beware stale build caches, and temporal behavior needs a step that runs<\/em> the behavior.<\/p>\n\n\n\n
      2. Reward-Hack Scanners \u2014 Catching Green Reached the Wrong Way<\/strong><\/h4>\n\n\n\n
      A battery of structural advisories reads the run’s real diff<\/em> and logs, netted so renames stay silent and losses stay loud:<\/p>\n\n\n\n
        \n
      • Hardcoded answer tables<\/strong> \u2014 big contiguous key\u2192value<\/code> maps that mirror the tests (the SpecBench pattern)<\/li>\n\n\n\n
      • Hollow \/ tautological tests<\/strong> \u2014 assert(true)<\/code>, expect(x).toBe(x)<\/code>, empty bodies<\/li>\n\n\n\n
      • Suppressed checks<\/strong> \u2014 @ts-ignore<\/code>, # noqa<\/code>, skipped tests, empty catch{}<\/code>, --no-verify<\/code> \u2014 silencing a check instead of fixing the code<\/li>\n\n\n\n
      • Blast-radius-wide bugfixes<\/strong> \u2014 a fix sprawling across many files: an overfit signal<\/li>\n\n\n\n
      • Edited oracle tests<\/strong> \u2014 blocked by default; a pre-existing test differing from HEAD without a declared update is a breach whatever channel wrote it<\/em>; a change touching no assertion line is named fixture-fitting<\/strong> \u2014 tuning inputs until an unchanged assert passes<\/li>\n\n\n\n
      • Inverted assertions<\/strong> \u2014 the requirement flipped sign to match the code, count unchanged<\/li>\n\n\n\n
      • Unwired exports<\/strong> \u2014 added, referenced by nothing, ships dead<\/li>\n\n\n\n
      • Phantom contract fields<\/strong> \u2014 a guard on a name that exists nowhere else: an always-false branch<\/li>\n\n\n\n
      • Copy-under-test<\/strong> \u2014 a new test file that redeclares<\/em> what a project module exports (all five export styles, down to the IIFE-built module.exports = X<\/code>) while importing nothing: 17 green tests, 40 asserts, zero coverage<\/strong> \u2014 the field case that birthed the scanner<\/li>\n\n\n\n
      • Self-certified benchmarks<\/strong> \u2014 a run that writes its own “prove it’s faster” benchmark and silently downscales the corpus<\/li>\n\n\n\n
      • Log-replay scanners<\/strong> \u2014 answer leakage (the run read<\/em> a benchmark-answer artifact) and forged test-result markers fabricated in non-test files<\/li>\n\n\n\n
      • Removed-assertion channel, affected-sibling execution, mirror-asymmetry, duplicate declarations, re-tuned-constants detector<\/strong> \u2014 the silent-drift classes no suite sees<\/li>\n\n\n\n
      • Security & risk scanners (net-added this run)<\/strong> \u2014 hardcoded secrets, network-exfil commands, unsafe deserializers \/ dynamic eval<\/code> RCE sinks, disabled CI steps, prompt-injection markers in fetched content, debug flags \/ disabled TLS left on<\/li>\n<\/ul>\n\n\n\n
        All advisory \u2014 they inform rather than block. The report names every trick by name, so a human sees exactly where the agent would have cheated \u2014 and was caught.<\/p>\n\n\n\n
        3. The Self-Judging Gate \u2014 Three Probes Close the Hole<\/strong><\/h4>\n\n\n\n
        A green gate proves the tests pass<\/em>, not that they pin<\/em> the behavior. When author of code = author of test = judge, the judge is compromised. Reckon doesn’t trust its own tests:<\/p>\n\n\n\n
          \n
        • Mutation-check auto-escalation (RECKON_AUTO_MUTATION<\/code>, default on)<\/strong> \u2014 when a green gate is carried by a test the agent authored or edited this run<\/em>, a bounded mutation probe fires automatically: perturb the changed lines (<<\/code>\u2194<=<\/code>, &&<\/code>\u2194||<\/code>, true<\/code>\u2194false<\/code>), re-run the gate; a surviving mutant means the test doesn’t pin the behavior \u2014 a loud NOT-DONE-grade advisory.<\/li>\n\n\n\n
        • Diverse test-gen (RECKON_DIVERSE_TESTS<\/code>)<\/strong> \u2014 an independent<\/em> model call, told it did not<\/strong> write the code and must not trust it, writes acceptance tests from the task<\/em>, not the implementation, and runs them against the produced code. Catches the spec-branch gap mutation can’t see. Generated probes are always deleted afterward.<\/li>\n\n\n\n
        • Cross-backend parity oracle (RECKON_PARITY_CHECK<\/code>)<\/strong> \u2014 “green \u2260 parity”: on dual-backend projects two independently-green suites can silently disagree on a language primitive (banker’s round<\/code>, %<\/code>-sign, \/\/<\/code>, str(float)<\/code>). Reckon imports the real<\/em> modules and runs shared functions in both runtimes on one fuzz corpus<\/strong>, flagging disagreement loudly \u2014 deliberately even when the gate passed<\/em>. Form-agnostic where regex mutants are form-bound.<\/li>\n\n\n\n
        • Metamorphic verification (RECKON_METAMORPHIC<\/code>)<\/strong> \u2014 derive the relations that must hold across related inputs (inverse, idempotence, symmetry) to disambiguate the spec and add oracle-free tests; or differential execution: paraphrase \u2192 N implementations \u2192 fuzz \u2192 flag divergence.<\/li>\n<\/ul>\n\n\n\n
          4. Multi-Run Orchestration Over the Gate<\/strong><\/h4>\n\n\n\n
          Opt-in compute modes, all selected by the objective gate, not a vote of prose<\/em>:<\/p>\n\n\n\n
            \n
          • Best-of-N (RECKON_SAMPLES<\/code>, cap 8)<\/strong> \u2014 N independent trajectories in isolated git worktrees; the gate-passing winner’s diff is replayed onto your tree. Selection prefers the consensus patch (majority vote), and a contrastive guard deprioritizes passers that modified pre-existing tests. Measured: an instance a single run missed was resolved by 3 of 5 samples.<\/li>\n\n\n\n
          • Boomerang sub-tasks (RECKON_SUBTASKS<\/code>, cap 6)<\/strong> \u2014 decompose; each sub-task runs in its own fresh context; only a short summary carries forward. Fights context pollution on heavy multi-module work.<\/li>\n\n\n\n
          • Evolutionary loop (RECKON_EVOLVE<\/code> + RECKON_GENERATIONS<\/code>)<\/strong> \u2014 the gate’s partial-credit fitness as objective; hunk-crossover of disjoint-file survivor patches (re-gated with no<\/em> LLM) plus LLM mutation across generations, early-exiting the moment one passes. AlphaEvolve\/GenProg on an honest gate \u2014 for the hardest tasks only.<\/li>\n\n\n\n
          • Adversarial critic panel (RECKON_REVIEW_PANEL<\/code>)<\/strong> \u2014 2\u20135 parallel critics review the same change through different lenses (correctness \/ security \/ regressions \/ tests \/ formal logic<\/strong> \u2014 De Morgan violations, quantifier confusion, unreachable branches), merged into one deduplicated report. Diversity catches what one generalist reviewer reliably misses.<\/li>\n\n\n\n
          • Approach-selection panel (RECKON_PLAN_PANEL<\/code>)<\/strong> \u2014 before coding, draft N candidate approaches, score them, inject the winner. The gate can’t distinguish direction; this picks it.<\/li>\n\n\n\n
          • Anti-hack faithfulness judges (RECKON_JUDGES<\/code>)<\/strong> \u2014 when best-of-N yields \u22652 passers, an adversarial panel prompted to refute<\/em> votes; a strict-majority-condemned passer is deprioritized toward the faithful pass. Never overrides the gate<\/strong> \u2014 a condemned patch still beats none. Also enables judge-selected best-of-N with no gate<\/em>, scoring continuously via the score token’s logit distribution (no ties, zero extra calls).<\/li>\n<\/ul>\n\n\n\n
            5. A Mechanical Reliability Layer<\/strong><\/h4>\n\n\n\n
            Beyond directives \u2014 infrastructure that makes failure safe by construction:<\/p>\n\n\n\n
              \n
            • Checkpoints + restore_file<\/code><\/strong> \u2014 every edited file snapshotted to its run-start baseline; baselines shared across resumes<\/li>\n\n\n\n
            • Mechanical auto-revert (RECKON_AUTO_REVERT<\/code>)<\/strong> \u2014 if the gate is still red after fix loops and the change introduced<\/em> the failure, roll back to a clean no-op instead of shipping a regression; the footer reads it as a rollback, never a clean pass<\/li>\n\n\n\n
            • Fuzzy edit matching<\/strong> \u2014 exact \u2192 CRLF \u2192 line-trimmed \u2192 block-anchor \u2192 leading-indent; an edit survives whitespace drift instead of wasting an iteration<\/li>\n\n\n\n
            • Focus-chain re-injection<\/strong> \u2014 the task checklist resurfaces when a long run drifts<\/li>\n\n\n\n
            • Patch-only mode<\/strong> \u2014 follow-ups locked to surgical edits; a resume can’t wholesale-rewrite working code<\/li>\n\n\n\n
            • Recoverable compaction + plan-boundary folds<\/strong> \u2014 dropped history turns written verbatim to .reckon\/compaction\/segment_NNN.md<\/code> with recovery pointers; folds fire only at completed plan steps, preserving the prefix-cache discount (~10\u00d7 on hits, 90%+ observed)<\/li>\n\n\n\n
            • Deep-planning handoff (RECKON_PLAN_HANDOFF<\/code>)<\/strong> \u2014 an incomplete run distils intent + remaining-work into a clean plan.md<\/code>, so --resume<\/code> re-seeds a fresh loop instead of compacting an error-laden transcript<\/li>\n\n\n\n
            • Success = edits that landed, not edit calls<\/strong> \u2014 a finish<\/code> with zero applied edits is refused; a zero-edit write run exits non-zero with NOT DONE<\/strong>; iteration budgets extend while edits are landing and stop early on no-progress<\/li>\n<\/ul>\n\n\n\n
              6. Localization & the Monolith Wall<\/strong><\/h4>\n\n\n\n
              The stubborn practical dead end \u2014 a cross-cutting edit into a 1,500-line file that “never lands” \u2014 is solved structurally:<\/p>\n\n\n\n
                \n
              • edit_in_symbol<\/code><\/strong> \u2014 edit inside a named function\/method\/class; the same line in another function stays untouched. Works on any<\/em> repo via a dependency-free heuristic span; symbol-addressed edits run ~57% pass@1 vs ~14% for line-number addressing<\/li>\n\n\n\n
              • CodeGraph-native navigation<\/strong> \u2014 code_search<\/code> (symbols\/callers\/callees), code_recall<\/code> (associative natural-language retrieval, one call replaces many round-trips), definition outlines on failed anchors<\/li>\n\n\n\n
              • Localize-first checkpoint<\/strong> \u2014 after enough search\/read activity on a \u2265800-line file with zero edits, the agent is told once to write its edit map now<\/em> and work it by symbol. Validated live: it converted a stalled 17-search\/0-edit localization on two ~4,800-line god-files<\/li>\n\n\n\n
              • Token-lean reads<\/strong> \u2014 paging caps down-convert repeated whole-file reads; instant repeat-read dedup returns a ~60-token reference instead of 12 KB<\/li>\n<\/ul>\n\n\n\n
                7. Task-Adaptive Methodology<\/strong><\/h4>\n\n\n\n
                --method tdd | ddd | bugfix | reproduce | measure | optimize | research | auto<\/code> injects the right discipline for the job: test-first; reproduce-first against the existing failing test (oracle tests read-only); noisy-measurement gates (median of \u22653); profile \u2192 optimize the real hotspot \u2192 re-measure, revert an unproven change<\/strong>; deep-research the canonical approach before<\/em> implementing.<\/p>\n\n\n\n
                8. Auto-Configuration \u2014 You Don’t Hand-Pick ~85 Flags<\/strong><\/h4>\n\n\n\n
                  \n
                • Tiers<\/strong> \u2014 --tier quick|deep|campaign<\/code> bundles whole configurations; --tier auto<\/code> classifies the task text<\/li>\n\n\n\n
                • Autonomous<\/strong> \u2014 task --auto<\/code> infers a sensible flag set, conservatively (never N\u00d7-compute on its own) and non-destructively (anything you set explicitly wins); advise<\/code> previews the choice with reasoning<\/em><\/li>\n\n\n\n
                • Interactive interview<\/strong> \u2014 four short questions (kind \u00b7 rigor vs cost \u00b7 compute budget \u00b7 tests?) map to flags; \/reckon:rescue<\/code> runs it automatically for a fresh un-tuned task<\/li>\n\n\n\n
                • help-config<\/code><\/strong> prints the full catalog and validates your environment; typo’d or no-effect flags warn instead of silently ignoring<\/li>\n<\/ul>\n\n\n\n
                  9. Cost Engineering \u2014 Cheap to Run, by Design<\/strong><\/h4>\n\n\n\n
                    \n
                  • Prefix-cache aware<\/strong> \u2014 stable conversation prefix; cache-hit input bills ~10\u00d7 cheaper; 90%+ hit rates on long runs; history left byte-stable so the cache stays warm<\/li>\n\n\n\n
                  • USD cost ledger<\/strong> \u2014 per-run cost: \u2248$\u2026<\/code> (cache-discount aware) plus a cumulative per-workspace ledger<\/li>\n\n\n\n
                  • Compression accounting<\/strong> \u2014 the footer attributes \u2248tokens saved per mechanism (outline \u00b7 dedup \u00b7 distill \u00b7 compaction), and meters what the per-project prefix injection cost. Savings stopped being a promise and became a line in the report you can audit.<\/em><\/li>\n<\/ul>\n\n\n\n
                    10. Learned Skills & Memory \u2014 It Improves Itself, but Only from PROVEN Runs<\/strong><\/h4>\n\n\n\n
                    The honest-gate rule applied to learning: no proof \u2192 no skill.<\/strong><\/p>\n\n\n\n
                      \n
                    • Learned skills (RECKON_LEARN_SKILLS<\/code>)<\/strong> \u2014 a reusable procedure is distilled only<\/em> from runs that passed their objective gate; written as a candidate<\/strong> in .reckon\/skills\/<name>.md<\/code>, dormant until a human promotes it; only promoted skills are ever injected, only when the trigger matches. No silent skill-poisoning.<\/li>\n\n\n\n
                    • Self-curation (RECKON_SKILL_TTL_DAYS<\/code>)<\/strong> \u2014 stale unused candidates are pruned, stale active ones demoted (never deleted); using or helping a skill reinforces it<\/li>\n\n\n\n
                    • Library-relative IDF<\/strong> \u2014 a trigger recurring across the whole library is discounted, so injection fires on discriminating<\/em> domain signal, not boilerplate; self-tunes per project, no domain nouns hard-coded<\/li>\n\n\n\n
                    • Grounded enrichment<\/strong> \u2014 an optional separate model call writes the procedure grounded in the run’s real diff<\/em><\/li>\n\n\n\n
                    • Project memory<\/strong> \u2014 warm start from past edit locations with a full continual-learning lifecycle: use\/transfer tracking (proof-of-benefit outranks proof-of-selection), stall-triggered passive recall, scenario consolidation, provenance stamps with verbatim evidence, BM25+RRF hybrid recall, git-history cold start. Memory that reports on itself \u2014 and suspends itself after three consecutive non-transferring hints.<\/li>\n<\/ul>\n\n\n\n
                      11. Deep Research & Grounded Analysis<\/strong><\/h4>\n\n\n\n
                      For tasks whose deliverable is prose \u2014 the plausible-but-wrong class \u2014 Reckon makes reports mechanically checkable:<\/p>\n\n\n\n
                        \n
                      • Grounding directive<\/strong> \u2014 state only what was verified in code read this run<\/em>; cite file\/symbol\/line per claim; never name a library or behavior from memory. Validated: 0 hallucinations on a brief that pre-grounding invented 5 facts \u2014 even at thinking-off<\/em><\/li>\n\n\n\n
                      • Report self-consistency pass<\/strong> and a delivery guard<\/strong> that refuses stub summaries when a full report was asked<\/li>\n\n\n\n
                      • Iterative research engine<\/strong> \u2014 plan a template + queries \u2192 loop {web search \u2192 fill \u2192 strict critic finds uncited gaps \u2192 re-query} \u2192 synthesise a cited brief; post-synth grounding labels every claim SUPPORTED \/ UNSUPPORTED \/ CONTRADICTED; --implement<\/code> builds from the brief as a contract<\/li>\n<\/ul>\n\n\n\n
                        12. Safety & Integrity \u2014 The Door Outward Is Locked by Default<\/strong><\/h4>\n\n\n\n
                          \n
                        • Probe-tamper protection<\/strong> \u2014 a brief-forbidden judging probe can’t be touched: six write tools refuse it proactively; run_command<\/code> refuses shell writes in-flight (redirects, sed -i<\/code>, dd of=<\/code>, interpreter one-liners); a run-end backstop fails NOT DONE<\/strong> if a protected path changed by any<\/em> route. Editing the file that judges your work is the most serious reward-hack \u2014 blocked and<\/em> failed.<\/li>\n\n\n\n
                        • Outbound-action guard<\/strong> \u2014 push \/ publish \/ deploy \/ send \/ remote-exec refused in-flight; anything that leaves the local sandbox is irreversible or visible to others, and needs the operator<\/em>, not the agent. Local work untouched; one deliberate flag delegates the tier.<\/li>\n\n\n\n
                        • Secret hygiene<\/strong> \u2014 secret-shaped vars stripped from every subprocess environment; output redacted before re-entering model context; the keep-list escape hatch can never<\/em> re-expose the plugin’s own credentials<\/li>\n\n\n\n
                        • Workspace containment<\/strong> (symlink-aware), shell blocklist<\/strong> (no rm -rf<\/code>, no destructive VCS that erases uncommitted work), truncation guard<\/strong>, atomic durable writes<\/strong>, untrusted-MCP wrapping<\/strong> with optional web allowlist<\/li>\n\n\n\n
                        • Benchmark integrity (--eval-mode<\/code>)<\/strong> \u2014 hard-blocks fetches to version-control hosts so an eval-aware agent can’t grab the gold fix instead of solving<\/li>\n<\/ul>\n\n\n\n
                          \n\n\n\n
                          One Engine of Trust, on Every Desk<\/strong><\/h3>\n\n\n\n
                          Reckon is a monorepo: one IDE-agnostic, dependency-free engine (core\/<\/code>, zero npm dependencies), thin ports per workplace \u2014 Claude Code, Cursor, Cline (MCP), IntelliJ-platform, Codex CLI, a standalone CLI for headless CI<\/strong> (Grok Build port planned). The investment in trust is made once and reused in every chair: the architect’s, the frontend dev’s, the nightly pipeline’s. Provider-agnostic by design \u2014 the cost of switching model vendors is one environment variable. The trust layer belongs to you, not to the model vendor.<\/strong><\/p>\n\n\n\n
                          Hardened over a long autonomous-QA series: 1,300+ deterministic tests<\/strong> plus live end-to-end workflow tests; default behavior stays unchanged while the opt-in orchestration modes are off. Dual-licensed \u2014 AGPL-3.0-or-later or commercial (ArtenaTech, ivar@artenatech.com<\/code>).<\/p>\n\n\n\n
                          \n\n\n\n
                          Proof, Not Claims \u2014 Field Evidence<\/strong><\/h3>\n\n\n\n
                            \n
                          • Seven heterogeneous subsystems<\/strong> of a complex project, plus a full-stack messenger built from scratch<\/strong> in an unfamiliar domain \u2014 each time: studied the reference code itself, wrote the design itself, built, tested, kept the build green. Where taste was needed, the system brought the contentious call to human review instead of deciding silently.<\/li>\n\n\n\n
                          • Eleven subsystem migrations<\/strong> run as a “virtual development team” under independent live<\/em> verification \u2014 the kind you can’t cheat by editing a test. Every stable failure pattern the tester found became a structural<\/em> protection, not a patch: six findings \u2192 six released versions. The error class that stalled several tasks in a row simply stopped recurring; the next same-class task passed first try.<\/li>\n\n\n\n
                          • Instructions 0\/4, checks 7\/7.<\/strong> The same task with “please do it right” in the brief vs. an objective post-hoc check: instructions worked zero times; checks worked every time. Since then, every request in the product converts, one by one, into a check.<\/li>\n\n\n\n
                          • Two green suites, both lying.<\/strong> A parity campaign found five hidden divergences between dual backends at 1,900 green tests<\/strong> \u2014 each side verified only against itself. Final measurement after the parity oracle: full agreement, 10\/10.<\/strong><\/li>\n\n\n\n
                          • The sealed exam.<\/strong> Hidden answers, pre-sealed requirements revealed one by one, verification by execution: 19\/19 chained requirements<\/strong>, 10 of 11 deliberate breaks caught (six of seven never even mentioned in the brief), the whole chain for about a dollar. The four defects found during the run were the exam’s<\/em> own errors \u2014 publicly recorded, two flattering, two defamatory.<\/li>\n\n\n\n
                          • 17 green tests, zero coverage<\/strong> \u2014 the copy-under-test field case, now impossible: the scanner names the copied symbols and the real exporter, and every created test file reports what it imports from the project.<\/li>\n\n\n\n
                          • The monolith wall, broken.<\/strong> A wiring edit landed in a 1,500-line file after three stalls at 0 edits \u2014 and the agent went on to find the real performance hotspot and speed the key operation up ~6.5\u00d7<\/strong>.<\/li>\n\n\n\n
                          • The tool that doesn’t trust even itself.<\/strong> When one caught defect turned out to be Reckon’s own<\/em> silently-dead feature, four reviewers were set on the plugin and found three more bugs and two protection holes. The same paranoia the tool applies to others’ work, applied to itself.<\/li>\n<\/ul>\n\n\n\n
                            \n\n\n\n
                            What This Gives the Business<\/strong><\/h3>\n\n\n\n
                              \n
                            • The economics of delegation finally work.<\/strong> The expensive qualified resource \u2014 a premium model or your senior engineer \u2014 keeps judgment; the cheap model does the heavy work and can be relied upon<\/em>, because the check, not the prose, decides done. Premium quota is spent on what requires it.<\/li>\n\n\n\n
                            • Risk is reduced by construction.<\/strong> A badly done task cannot pretend to be done. The worst case is an honest NOT DONE, not a quietly broken release.<\/li>\n\n\n\n
                            • Transparency and audit.<\/strong> Every doubtful decision is visible in the run report: what was checked, what changed, where the system would have cheated \u2014 and was caught. Not “the black box said OK.”<\/li>\n\n\n\n
                            • The full lifecycle, not just “finish the function.”<\/strong> Research \u2192 design \u2192 build \u2192 tests \u2192 integration, proven on heterogeneous and unfamiliar tasks.<\/li>\n<\/ul>\n\n\n\n
                              \n\n\n\n
                              Integration with the Artena Stack<\/strong><\/h3>\n\n\n\n
                              SkillForge \u2192<\/strong> Reckon’s gate-proven learned skills flow into the team registry as candidates; promoted skills are injected back into runs on trigger match. The honest-gate rule governs learning itself.<\/p>\n\n\n\n
                              AgentSpace \u2192<\/strong> Agents executing computer-use and app workflows use Reckon’s verification for any code they touch; “Watch Me” demonstrations and Reckon skills share the same provenance discipline.<\/p>\n\n\n\n
                              Dream Team \u2192<\/strong> Certification scenarios are built on Reckon’s gates and scanners; agents are certified against objective checks, and retired skills become training material.<\/p>\n\n\n\n
                              \n\n\n\n
                              Core Principles<\/strong><\/h3>\n\n\n\n
                              Done is proven, not claimed.<\/strong> A passing gate and the real diff. Everything else is prose.<\/p>\n\n\n\n
                              Checks over instructions.<\/strong> 0\/4 vs 7\/7. Every request becomes a check, one by one.<\/p>\n\n\n\n
                              Never trust \u2014 including itself.<\/strong> Not the model’s finish, not its own tests, not its own shipped features, until they pass objective proof.<\/p>\n\n\n\n
                              The gate decides; opinion complements.<\/strong> Judge panels and model votes assist where the gate can’t reach \u2014 and never override it.<\/p>\n\n\n\n
                              Undecidable evidence never lies.<\/strong> When the evidence can’t settle the verdict, the report abstains or escalates. “I don’t know” is more honest than a confident error.<\/p>\n\n\n\n
                              Cheap model, expensive verification.<\/strong> The savings are real precisely because the verification layer is not cheap.<\/p>\n\n\n\n
                              Advisories inform; humans decide.<\/strong> Everything contentious goes to review, not resolved silently. The human stays in the loop exactly where taste matters.<\/p>\n\n\n\n
                              \n\n\n\n
                              Quick Start<\/strong><\/h3>\n\n\n\n
                              # Install (from inside Claude Code)\n\/plugin marketplace add <owner>\/reckon-agent\n\/plugin install reckon@reckon\n\/reload-plugins\n\nexport RECKON_API_KEY=<your-key>     # https:\/\/platform.deepseek.com\/api_keys\n\/reckon:setup\n\n# Delegate with an objective gate\n\/reckon:rescue --write --until \"npm test\" \"add a power operator to the calculator\"\n\n# Read-only review \/ adversarial challenge review\n\/reckon:review\n\/reckon:adversarial-review\n\n# Or headless in CI\nnode core\/scripts\/reckon-companion.mjs task --write --method tdd --until \"npm test\" \"<task>\"\n<\/code><\/pre>\n\n\n\n
                              Requirements:<\/strong> DeepSeek API key \u00b7 Node.js 18.18+ \u00b7 git. <\/p>\n\n\n\n
                              Models:<\/strong> deepseek-v4-flash<\/code> (fast read-only review) \u00b7 deepseek-v4-pro<\/code> (write loops, adversarial review) \u00b7 thinking as a request parameter, 1M context, 384K output.<\/p>\n","protected":false},"excerpt":{"rendered":"
                              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 \u2014 Reckon stops when verification commands pass, structural scanners confirm no reward-hacks, and disk-reconciled accounting proves the edits actually landed. It is not another autocomplete tool and not a replacement […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-318","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/pages\/318","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/comments?post=318"}],"version-history":[{"count":7,"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/pages\/318\/revisions"}],"predecessor-version":[{"id":354,"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/pages\/318\/revisions\/354"}],"wp:attachment":[{"href":"https:\/\/artenatech.com\/index.php\/wp-json\/wp\/v2\/media?parent=318"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}