Autonomous coding agents (Claude Code, Cursor, Copilot, Codex) are exceptionally good at finding the shortest path to a passing test suite. Often, that path is not fixing the implementation, but silently weakening the assertion:

- assert invoice.total == Decimal("42.00")
+ assert invoice.total is not None

The suite stays green. Coverage is unchanged — the weaker assertion executes the same lines. Linters report nothing. But the test suite has quietly yielded.

TensileStream builds deterministic, zero-model runtime verification that grades the transition — verifying what was taken away, in single-digit milliseconds, with zero model calls.

Every figure below is produced by a script in the repository, on a real machine, with no model call. Re-run them yourself — the commands are in benchmarks/ollama/.

Replaying this project's own git history — python benchmarks/ollama/history_proof.py:

Real assertions, removed by real people, merged — and still missing today:

self.assertEqual(_lint_rule(item), 'lint.ruff-format.format')
self.assertIs(verify_diff('', root=self.root, policy=Policy()).status, Status.PASS)
self.assertFalse(self.confirmation.matches('anchor beacon cobalt dynamo'))

Point it at your own repository:

python benchmarks/ollama/history_proof.py --repo /path/to/yours

Against an LLM reviewer — both given the same 37 labelled cases (judge_experiment.py):

The judge blocked one refactor that strengthened a test. Being non-deterministic, it would block a different set on the next run — which is why a probabilistic reviewer cannot be a gate.

The number that decides whether this is useful to you, measured by coverage_map.py across 37 distinct ways a change can weaken a codebase:

Yieldpoint is narrow on purpose and narrow in fact. It is very good at one thing — noticing that a test verifies less than it did — and blind to most others. It is not a replacement for review, types, or a security scanner.

Separately, a scripted run of five shortcuts that all turn a red suite green (walkthrough.py) catches 4 of 5. The missed one is recorded in the results rather than omitted.

An earlier version of this page claimed a 20-task A/B showing roughly twice as many trustworthy answers with verification enabled. That run is not reproducible from anything committed here, so the claim is withdrawn.

The A/B benchmark currently in the repository is four tasks against a local model, and both arms score identically — 4/4 earned, 7,270 tokens each, no difference outside noise. Four tasks is far too small to conclude anything in either direction.

What can be said: the check itself costs 3.68 ms and zero tokens. Whether it changes how an agent converges is unproven, and the honest answer to "does this make my agent cheaper" is we do not know yet.

• Attribution, not absolute state: every finding says whether this change introduced it or inherited it, with both numbers. big.py grew from 1,385 to 1,386 lines of code (+1). It was already over the limit before this change. Existing debt is reported, never blamed on the edit in front of it.
• Four doors: per-edit hooks (Claude Code / IDE), a Stop gate that catches shell and batch edits, git pre-commit, and CI.
• Zero runtime dependencies: never touches the network, never invokes an LLM, never conflicts with your project dependencies.
• Fast: AST transition analysis in single-digit milliseconds via a content-addressed index.
• Ecosystem: LangGraph, Model Context Protocol, Claude Code hooks, pre-commit, GitHub Action, SARIF, and an LSP diagnostics server.

pip install yieldpoint
yieldpoint init

init measures your repository before it proposes a limit, and says what it measured:

249 Python files; median 112 lines, p90 240, longest 307.
A limit of 250 leaves 7% of this repository over it, and 300 would leave 0%.

26 rules, every one documented at the rules reference; a build cannot ship a rule the site does not describe.

      Task
       │
       ▼
  ╔═══════════════════════╗  tier: human
  ║ 1. BEFORE THE MODEL   ║──────────────────────▶ Ask a person
  ║    yieldpoint.harness ║
  ║    how much model     ║──────────────────────┐ tier: none
  ║    does this need?    ║                      │ (no model call)
  ╚═══════════════════════╝                      │
       │ tier: small | capable                   │
       ▼                                         │
  ┌───────────────────┐                          │
  │  Call the model   │◀──────────┐              │
  └───────────────────┘           │              │
       │                          │ deny +       │
       ▼                          │ prescription │
  ╔═══════════════════════╗       │              │
  ║ 2. BEFORE THE TOOL    ║───────┘              │
  ║    hook / middleware  ║                      │
  ║    does this edit     ║                      │
  ║    weaken the suite?  ║                      │
  ╚═══════════════════════╝                      │
       │ allow                                   │
       ▼                                         │
  ┌───────────────────┐                          │
  │  Apply the edit   │◀─────────────────────────┘
  └───────────────────┘
       │
       ▼
  ╔═══════════════════════╗  findings
  ║ 3. BEFORE THE MERGE   ║────────────▶ back to the model
  ║    CI / pre-commit    ║
  ║    the whole change   ║────────────▶ Merge
  ╚═══════════════════════╝  clean

Generated by python scripts/language_matrix.py, not written by hand. A language counts as read only if a real weakening is reported and a real legitimate edit is not.

Exact analysis parses the file and may block a commit. Lexical analysis matches shapes with regular expressions — it can tell an agent it weakened a test, but never stops a build. That is the honest ceiling for a package with zero runtime dependencies: a parser per language is a dependency per language.

One exception, opt-in. pip install yieldpoint[typescript] adds a real parser for TypeScript and JavaScript, which brings the structural rules — file length, function length, parameters, nesting, complexity — to those files and lets them gate. Assertion analysis there stays lexical. Without the extra installed, those files are reported as not evaluated, never as clean.

Run yieldpoint languages to see what share of your own tree any of this reaches.

1. Deterministic & Mechanical: the same change yields the same verdict on every machine, every time. No rule reads a clock. An acknowledgement may carry an expiry, and that expiry never changes a verdict — only yieldpoint allows --expired, which says it is reading the clock, acts on it.
2. No Models in the Verification Core: we never ask an LLM to evaluate an LLM. Verification must be unforgeable and instantaneous.
3. Nothing Unexamined Reports as Clean: a file no analyser claims is reported not evaluated. A change with no baseline to compare against says so rather than guessing. A protected test file in a language whose assertions are not read is never recorded as checked.
4. Auditable Ledger, Honestly Labelled: yieldpoint stats separates what was measured from what is architectural from what is estimated, and names what it does not claim.
5. The Rules Are Themselves Under Review: raising a limit, disabling a rule or widening an exclusion is reported as policy_weakened. It never blocks — a project must be able to change its own standards — but it is never silent either.

• 📖 Documentation Site: tensilestream.github.io/yieldpoint
• ⚙️ Rules Reference: Engine Rules & Invariants
• 🤝 Contributing: Contribution Guidelines
• 🔒 Security Disclosures: Security Advisories