New The goal contract — accomplish these things, subject to these policies. What's new →

Keep up with your AI-generated code.

The old code-review model is out. Agents generate too much code, too quickly, for diff-by-diff review to keep pace. ponens is the review model that keeps up.

ponens makes each agent session reviewable at a higher level — a curated, verifiable reasoning trace of what was built and why. It judges that trace against a goal stated as a contract — accomplish these things, subject to these policies — and returns three deterministic verdicts: met (the criteria hold, checked against the trace's own evidence), governed (your policies held — Computable Governance), and certified (a human confirmed the criteria were the right ones).

pip install ponens See a trace → Policy gallery →

Already 211 computable policies across 13 packs from 10 organizations.

Not another tracing tool

ponens doesn't compete with OpenTelemetry, Langfuse, or LangSmith — it sits on top of them. Observability is descriptive: it records what happened — spans, latency, tokens — but renders no verdict on it. ponens is evaluative: it judges each trace against the goal contract and returns met ∧ governed ∧ certified — a deterministic verdict, not a dashboard to eyeball.

	ObservabilityOpenTelemetry · Langfuse · LangSmith	ponens
The unit	an execution span / request — no notion of intent	a declared goal + its definition of done
The question	What happened? — spans, latency, tokens, cost	Did it meet its goal — and was that the right goal?
The record	execution spans / LLM calls	a curated reasoning trace — actions, lineage, intent, declared gaps
The check	dashboards, eyeballing, thresholds	deterministic policy verdicts — machine-checked 🟢 🟡 🔴
Done means	the run finished (or errored)	met ∧ governed ∧ certified — criteria resolved from evidence, policies held, and a reviewer confirmed the criteria were right
The output	metrics + traces to inspect	a PASS/FAIL governance gate + the declared residual surface
Where it runs	a dashboard	offline, in CI, or a runtime gate — no model in the loop

Bring your traces with you

Already instrumented? Pipe your spans straight in and add the governance layer:

ponens otel import spans.json -o t.json
ponens langfuse import lf.json -o t.json
ponens trace check t.json    # → 🟢 / 🔴

Same run — now with computable policies, a decision path, and declared residuals. Import guide →

From session to reasoning record

ponens reads the agent's raw session and distills it into a reasoning record you can judge. Three nouns carry the whole model:

Trace: The curated record of one agent session — the actions taken, the artifacts they produced, and the lineage linking them. What happened.
Goal: The contract the session pursued — what to accomplish (typed acceptance criteria over your code), subject to which policies. The definition of done.
Policy: A machine-checkable rule evaluated over the trace, written in LTLf. The rigor bar.

ponens checks a goal against a trace, subject to its policies — and returns three independent verdicts: met (criteria resolve from the trace's own evidence, not a model's opinion), governed (the policies held), and certified (a human confirmed the criteria were the right ones).

Three, because an agent that writes and meets its own definition of done can pass a bar it set too low — so the rigor bar is a human's, and a "done" resting only on edits landing is flagged. Goal faithfulness → · Goal contract →

Agent session ~/payment-service

Youmake capture idempotent

Readpayment.py

Editpayment.py

Youyes

Bashpytest✓ 24 passed

Youok now handle refunds too

Editpayment.py

Bashgit commit -m "fix"

A reasoning record Open demo →

Goal make capture idempotent met governed certified · awaiting review

Flow · 4 steps

m1Understand the capture pathdone

m2Prove no double-chargeproved

m3Implement & testdone

m4Commit1 action

Lineage

assumes a stable idempotency key unverified Grade B · lineage 100% · policies 4/4 ✓

Governance you can compute

Best-practice rules — research before editing, tests before commit, proofs on high-stakes paths — as machine-checked formulas over the trace, not a checklist a human eyeballs.

The problem

A reasoning trace in prose can't be enforced. "I ran the tests before committing" is a sentence, not a guarantee. The practices you actually care about have no teeth when they live in a checklist someone skims under deadline.

The solution

ponens gives the trace a typed schema — atomic actions, artifacts, a lineage DAG, a residual surface — then encodes each policy as a formula in LTLf (linear temporal logic over finite traces), extended with scoped-past (P_chain, P_target) and structural operators. The CLI compiles each formula and evaluates it over the trace: a deterministic PASS / FAIL, run offline in CI. Same foundation as DECLARE / declarative process mining and runtime verification — pointed at AI agents.

policies.ltlevaluated over the trace · PASS / FAIL

tests_before_commit pure temporal

G(GitCommit → P(RunTests ∧ completed))

every commit is preceded by a test run that completed

research_before_edit scoped past

G(EditFile → P_target(ReadFile ∨ ReadDocumentation ∨ SearchCode ∨ AnalyzeCode))

no edit without first reading or searching the relevant code

reasoning_required_for_high_stakes scoped past

G(EditFile ∧ high_stakes_path → P_chain(VerificationResult(proved ∨ sat) ∨ Decomposition))

on a high-stakes path, an edit must be backed by a proof, a SAT result, or a decomposition

no_open_critical_residuals structural

¬∃ r ∈ residuals . r.severity = Critical ∧ r.status = Open

the trace can't ship with an unresolved critical gap

The full operator reference is in the Policy Language spec, and 40+ ready policies are in the gallery.

How review works with ponens

Developer + AI agent

writes the code

Declare the goal & emit the record

The agent states its goal, then turns the session into a reasoning trace.

Grade & govern

The quality grade and Computable Governance run in CI.

Open the PR

The record posts on the pull request, beside the diff.

AI auditor (LLM)

audits & confirms

Re-check the claims

An LLM re-derives each claim from the evidence in the trace.

Confirm what holds

Marks the reasoning it can independently re-derive.

Flag the rest

Escalates only what it can't confirm to a human.

Reviewer

checks the work

Read the flagged gaps

Just what the audit couldn't confirm — a short list.

Verify what matters

Check the consequential claims; skip the noise.

Certify & merge

The reviewer certifies the definition of done was the right one — met by the agent, governed by its policies, certified by a non-doer. Bound 1:1 to the commit.

Quickstart

pip install ponens                              # Install

ponens agent                                    # The whole workflow, in one command
ponens emit -o trace.json                       # Capture the session as a trace
ponens trace meta set trace.json m3 --title "…" # Curate the narrative
ponens trace grade trace.json                   # The quality rubric
ponens trace check trace.json                   # Computable Governance — policies + goal faithfulness
ponens trace view trace.json                    # Read the reasoning, zoomable

Practical guides

Short, copy-pasteable how-tos for real tasks. All guides →

Author

Capture & curate a trace

Turn an agent session into a clean, honest reasoning record.

Reviewer

Review an AI-generated PR

Start from the declared gaps; verify what matters; skip the noise.

Maintainer

Add ponens to CI

Grade, gaps, and a viewer on every PR — plus a PASS/FAIL gate.

Maintainer

Govern a repo with policies

Best-practice rules checked over every trace, offline.

Open source — built in the open

ponens is MIT-licensed, and the moving parts grow with the community: the policy gallery, the reasoner registry, the agent adapters, and the trace & policy spec. Add a best-practice policy, register an automated-reasoning tool, write an adapter for your agent, or help shape the spec.

Star on GitHub Read CONTRIBUTING →