How reassuring.
One agent maps the change.
One implements it.
Another arrives afterward and tries to prove it wrong.
The last one is called Soul.
Green is a color
Coherence is not correctness.
An agent that plans a change, implements it, writes the tests, runs them and reports success has produced a very coherent account of events. The tests pin its own reading of the task. The report is written by the party with the most reason to believe it.
First there was Epiphany
Local productivity outran global understanding.
Coding agents are fast enough to make a locally sensible change, then another, then another, while the architecture quietly stops making sense. Tests pass. Tasks close. Everyone has receipts.
GameCult started building Epiphany: a Mind for a project that survives the workers thinking about it. She is still under construction. She is very particular about her body.
Eureka is her sister
We still had software to ship.
So the process Epiphany embodies became practice first: separate understanding from execution, write the promises down, keep the evidence, and send in somebody who did not write the thing. Then an agent was asked to formalise it and run it against a real migration.
The migration did not invent the method. It was the first time the method had to explain itself.
Nothing grades itself
Five organs. One operator.
Eureka splits a change across faculties inherited from Epiphany's anatomy. Each one owns a single job, and none of them certifies its own work.
Imagination
Maps the change before anyone touches it.
Behavioural promises, ownership boundaries, deletions, verification obligations, and the decisions that actually need a human. The point is not a large specification. The point is to make it hard for implementation to quietly redefine the task.
Hands
One bounded cut at a time.
Hands follows the map and does not edit it afterward so the route taken becomes the route intended. The good ones stop at forks: one refused to break 104 scene references; another reported that its own mutation passed because the test read expected values from the code under test.
Soul
Assumes something is wrong.
Soul does not trust the implementation report, or green tests because they are green. It builds its own probes, attacks the promises, and mutates the code to see whether the evidence can tell right from plausibly wrong. Its job is to make the code regret making promises.
Self
Routes the work. Is not infallible.
Self coordinates the campaign and brings real product decisions back to the operator. Not every ambiguity deserves autonomy. Not every inconvenience deserves a meeting. Separating the faculties catches the implementer; it does not make the coordinator right, and the operator corrects it.
Life
Carries the thread.
Continuity through compaction, sleep and restart. Life keeps durable state honest at every phase boundary, because memory that quietly rewrites itself is a feature right up until it matters.
The operator
The sixth seat is yours.
Where Epiphany keeps her Face, Eureka keeps a human. The operator owns the decisions that are actually decisions. Machines are very capable. That does not make responsibility disappear.
Better prompts are lovely
The same reasoning writes the code and the tests.
The interpretation that produced the implementation tends to produce the tests that approve it. Asking the same system to look harder helps. Giving another system the explicit job of proving it wrong helps more.
Mutation testing is rude.
Clamp something that should pass through.
Drop a write.
Invert an authority check.
If the tests stay green, the tests have learned something about themselves.
Incorrect software is under no obligation to look suspicious.
The first formal campaign
29 of 32 falsification passes found real defects.
About 75 in all, every one behind the implementer's green suite. One supposedly untestable rule took fifteen lines and a millisecond to falsify. One document was accepted while being 86,751 bytes too large for the transport required to return it.
Specimen 01 / CultLib QUIC transport
Every overlay would have dropped ten seconds after connecting.
A handler swap meant the provider never recorded CONNECTED, so its handshake timer evicted healthy peers. No test lived past ten seconds.
Specimen 02 / native binding
A use-after-free in release().
It only showed under thread-pool saturation, where Soul reproduced it as a core dump. It is now pinned by a regression test that crashes with the old order.
Specimen 03 / native binding
About 53 bytes leaked per native call.
Roughly 36 MB a day while idle, gigabytes under load, and a perfectly flat JavaScript heap the whole time. Every check that looked at the heap was telling the truth about the wrong thing.
Specimen 04 / StreamPixels
Every subathon event after the first would have failed.
A fractional value was written to an integer column. The tests used whole-second fake timers, so the fraction never existed there.
Specimen 05 / a test double
The fake was kinder than the real thing.
The fake executor gave every beat its own completion callback. The real one had a single shared slot. A late finish released the next beat early, and animations overlapped.
It did not stop happening.
The defects change.
The pattern does not.
Every rule has a body count
The rules are accumulated damage.
Do not let implementation edit its own map. Measure real transport boundaries. Do not call a behaviour untestable because the first agent lacked imagination. Each rule exists because a reasonable alternative failed, and the changelog keeps the evidence. The scars stay.
Expense
Several agents cost more than one.
They repeat work, and Soul builds probes whose main purpose is proving Hands wrong. That spend is the work. Self's job is to aim it: one Soul gate per cut, and cuts small enough that Hands never drowns in its own context. We remain devastated by the expense of finding bugs before shipping them.
Epiphany and Eureka
Same organs. Different bodies.
Epiphany is the organism: eight organs, shared governed state, durable memory, and coordination without a human typing Continue all day. She is still growing bones. Eureka is the field kit built while we wait. The two are developing side by side on one shared substrate.
Open by design
Use it. Fork it. Read every rule.
If your campaign finds a failure mode we have not seen, that is more interesting. The plan is for Eureka to offer a sanitised evidence contribution after a campaign: the operator sees the payload and decides whether it leaves. No background telemetry. Consent keeps working even when the data would be useful.
Install
Point it at something unpleasant.
git clone https://github.com/GameCult/Eureka.git ~/.claude/skills/eurekaClaude Code finds the skill from its SKILL.md. The source is GameCult/Eureka. For the larger machine she came from, see GameCult/Epiphany, and bring patience.
GameCult builds open infrastructure for coordinated work between people, projects and agents. The workflow is free. Learning every lesson personally remains available at market rates.