Now you can
make AI agents
check their
own work.
For developers using Claude Code and Codex: a free, open-source tool your agent calls before it says a change is done. G6 runs the tests the change touches, looks for weakened tests, and shows each defect it reproduces. It says what it could not check, and can check a change against a formal mathematical model of what it must do, replaying counterexamples on your code.
Beside this text, G6's components are drawn as a lattice with the meta-harness at its centre. As you scroll, it acts out the four steps of G6's loop, then lights the components that answer each limit.
AI builds.
Evidence
decides.
A harness is everything around a model: what it sees, how its answers are checked, what it may do. Agents can propose application redesigns through four steps of controlled experimentation; iterative self-improvement is made possible through metacognition over MCP.
-
1
Propose
G6 finds where your task goes wrong and drafts fixes: a sharper prompt, an extra check, a repair step.
-
2
Test
Each fix is compared with the baseline on registered held-out tasks. Independence depends on keeping those tasks from the proposer. When one loses, G6 says why.
-
3
Gate
A statistical gate keeps a fix only when it clearly beats what runs now.
-
4
Approve
Nothing changes until you say yes. Every change is recorded, and can be rolled back.
Every limit, answered in the harness
Each one comes from how models are built. G6 answers it around the model, and the lattice lights the components that do it.
-
They make things up
A model writes the likeliest words, true or not.
G6 checks each claim against your sources and labels every result for what the evidence supports.
-
They forget, and read only so much
Nothing carries over between conversations, and the context window is finite.
G6 gives each call just what it needs, marked with its source, and keeps lessons as hints you approve.
-
They cannot learn on the job
What a model knows is fixed in its weights, and retraining can erase it.
G6 learns in the harness instead, so your model never changes and forgets nothing.
The self-tuning loopLearned hintsChange approvalRead the essay
-
They slip on logic and exact work
Matching patterns makes a wrong sum read as right.
G6 hands exact work to solvers, a proof checker, algebra and rule engines, and checks what they return.
The logic checkerThe proof checkerThe algebra checkerThe rule engineThe state machine checkerThe optimiserRead the essay
-
They redo routine work from scratch
Every call solves the problem afresh, at full cost.
G6 synthesises programs, and swaps repeated calls for small functions that pass tests on new cases.
-
They ace benchmarks, then stumble at work
Public tests reward what is easy to score, and may be in the training data.
G6 judges every change on your own held-out examples, never on a public score.
-
They do not know what they do not know
To a model, a guess and a fact sound the same.
Every G6 result says what was checked: verified, a qualified draft, or blocked with the reason.
-
They say it is done when it is not
Nothing inside an agent checks its own finish.
G6 fixes what done means before work starts, and holds the agent's report to the evidence.
-
They are unsafe to let act, or improve themselves
A model has no brakes, and could rewrite its own checks.
G6 gates every action, keeps a stop switch, and puts no change live without evidence and your approval.
The action gateRun limitsTamper scannersChange approvalRead the essay
-
The best models cost the most
Frontier models charge for every call, and most work repeats.
A frontier model engineers the harness once; a small model on your own computer then runs it, with no fee per call.
Two parts, batteries included
The meta-harness learns.
It tests changes to how it runs on cases it has never seen, keeps what wins once you approve, and can never touch the checks that judge it.
How the meta-harness worksThe components know how AI fails.
A prebuilt library of AI primitives, each extending what a model can do or closing one way it fails. Built from some 250 million tokens of hand-reviewed failure traces, towards a complete set: a periodic table of intelligence.
See the componentsReason
Act safely
A different kind of learning
- Task
- GSM8K, in the last development run
- Before
- No prompt at all
- After
- Work through the problem step by step. Then write the final answer on its own last line as 'Answer: <number>'.
- Held-out test
- won 21, lost 0, of 40 tasks
- Found and kept in
- 9.4 minutes
- From its own experiments
- run on cases held out from it.
- From plain words
- passed on by your coding agent.
- With a model of itself
- every part and setting written down.
Give it a task you can check and enough examples, and nothing in its design caps how far it can go on that task, up to training a model of its own. The working theory
What that gives you
Work that checks itself.
Every result carries one of three labels, and says why: verified qualified-draft blocked-escalated
Agents you can deploy safely.
Every action gated, a stop switch, and no change without your approval.
A specialist, without training a model.
Your agent, your data, your examples. Your model's weights never change.
Frontier judgement at local cost.
A frontier model engineers the harness once; a small model on your computer runs it, with no fee per call.
A worked example: G6 engineering itself, on a local model
Not a benchmark: llama3.1:8b, an 8-billion-parameter model on one computer, before and after G6 engineered its harness, on 100 fresh tasks per task set. On your work, results will vary with the task and the data you have.
GSM8K
2281
Winning option: G6, self-tuned
MASSIVE
6577
Winning option: G6, random changes, same gate
SciFact
5273
Winning option: G6, self-tuned
MBPP
5463
Winning option: G6, every component on
Grey is the model alone; black is G6. With the fixed self-tuning arm D, G6 solved 266 of 400 tasks the model alone solved 193 of: a larger model's judgement, distilled into a small model's harness, with no weights changed. In the last development run, the G6 development fixture recorded tested changes on GSM8K in 9.4 minutes (21 to 81 of 100). How to read these results
What else it found
A finding: two ways to engineer, and both matter. In the registered study, G6's prebuilt components, switched on together, beat the model alone on all 4 task sets (246 of 400), including MASSIVE (65 to 73) and MBPP (54 to 63), where self-tuning's gate could not yet confirm its changes. The two are alternatives, not a stack: in the last development run, self-tuning that started from every component had no change approved, and on SciFact every component on did worse than the model alone (57 against 64). Which approach won where
Each component on its own helps some tasks and hurts others: from +64 of 100 (the prompt “Work through the problem step by step…”, on GSM8K) to −33 (check a “supports” verdict against the abstract, on SciFact). G6 keeps only what wins on your own held-out cases. What each component does, on six datasets
What happened when we tried it
We gave Claude Code with Claude Sonnet 5.5 ten recent, real bugs in black, pydantic, starlette, click, attrs and fastapi, with G6 over MCP. G6 reproduced no defect. Six of the ten patches failed the maintainers' tests: G6 asked for more evidence, accepted the patch within the checks the agent stated, or raised an alarm that turned out to be false. We fixed what it taught us.
That is G6 today: a careful, isolated check of what your agent states, not yet a defect finder. A second round turned on G6's own model, also Claude Sonnet 5.5, in every review of the same ten bugs: it proposed 51 checks, and none found a defect. Five of the ten new patches failed the maintainers' tests. Making G6 a defect finder is the self-improvement loop's first job. All ten runs
G6 maintaining G6, in public
We're building a loop in which G6 maintains its own GitHub repository. It finds where G6 falls short, has Claude Code and Codex work on the biggest gap in isolated containers, checks every change with G6's own review, and opens a pull request. A maintainer reviews and merges every change.
Everything is public: the code, the decisions, the evidence and the agents' transcripts. It's an open experiment in self-improvement infrastructure for AI agents, and we'll report what it shows, including if it doesn't help. Read the design
Start in two commands
No account and no hosted service: G6 runs on your computer.
First make G6's own environment with python -m venv --copies .venv and
activate it. Get started shows the commands
for each system.
git clone https://github.com/basicisabc1994/g6solver && cd g6solver
pip install ".[all]" && g6 setup --client claude --allow patch_review.reviewFor Codex, use --client codex. The Get started page shows the first review.
You decide how deep it goes
Three levels of access, all open now. Every change still needs your approval.
The core harness as shipped: G6 tunes prompts, checks, steps and examples for your task. For anyone; the fastest start.
Every component, core and extensions: your agent finds the ones a task needs and combines them. For builders who want more control.
The whole source, yours to read, change and extend with your own components. For engineers: it is your copy.