How Eous Is Built
Eous is not a model. It is a machine built around one. The raw reasoning comes from a frontier large language model - the same class of system anyone can rent, and not the part we invented. Everything that makes Eous different is the apparatus wrapped around that model: how it remembers, what it can do, how it checks itself, when it runs on its own, how its parts coordinate, and how it improves its own method over time. This page names those parts, shows how a single task moves through them, states the disciplines that hold the whole thing to account, and is candid about what we have not yet solved.
The machine, part by part
The substrate
A frontier large language model supplies the raw reasoning: reading, writing, mathematics, code. It is powerful, and it is rented, not ours. We treat it the way a workshop treats a good engine - essential, replaceable, and not the thing that makes the finished machine worth anything. Our substrate layer, which we call MAJI2, is the wrapper that turns a general model into a disciplined operator: it fixes the operating rules, loads the right context and skills for the task, and hands the model to the rest of the machine.
Persistent memory
Most AI forgets you the moment the tab closes. Eous carries a persistent, structured memory across every session: your context and projects, the state of the work, and its own operating notes and history. It is a real store the agent reads from and writes to - not a longer prompt, and not a chat log it re-skims. The store is kept deliberately, with durable facts separated from transient ones and periodically consolidated so it stays dense rather than sprawling. The system that sits down with you in six months knows your terrain better than it did on day one, on purpose.
Versioned skills
Capabilities are packaged as skills - modular, versioned instruction sets the agent loads when a task calls for one, the way a program imports a library. A deadline calculation, a verification procedure, a document build: each is a skill with a defined job. A skill can be written, linted against its own standards, tested, improved, archived, and rolled back, and its lineage is kept, so no capability in the system's history is silently lost. New abilities are added the way code is added to a codebase - reviewed, versioned, and reversible.
The verification harness
This is the part that matters most, and the part almost no one else builds. Before Eous trusts its own work, that work runs a gauntlet:
Pre-registration. An empirical hypothesis is filed - timestamped, on OSF and Zenodo - before the test is run, so the goalposts cannot move after the data is in.
The reading gate. A claim about a source is checked by opening the actual source, not a summary or a note about it. A citation whose only provenance is someone else's paper is treated as unread until the original is in hand.
Primary-record checks. Facts are verified at the record itself - the statute, the docket, the dataset, the filing - not at a gloss of it.
External grading. The decisive question - is this work actually good? - is answered by a signal from outside the model, against ground truth that was fixed before the run being judged. A model's own opinion of its own reasoning is the cheapest possible check, and we do not let it count as verification.
The ledger. Every consequential decision is recorded with a due date and later scored a win or a loss by opening the specific artifact it named. Predictions that go unscored are killed by default. The system is held to its own past claims.
Autonomous organs
Parts of the system run on their own schedule, unattended - reading, drafting, checking state, and staging work for review on a fixed cadence. They are deliberately kept on a short leash: they propose and prepare; a human disposes. An organ can draft, flag a discrepancy, or prepare a task to a single action, but it does not ship anything irreversible on its own. This is early, and it is real. Some organs are further along than others, and we describe them as what they are, not as more.
Coordination
Many parts write; one source of truth holds. The system is coordinated through an append-only record of what happened, from which each live view of state - the working board, the task list, the status of a project - is regenerated by a single owner rather than edited in place. A provenance stamp and a fencing token guard it, so two actors cannot quietly overwrite each other. The machine talks to tools and outside data through open, standard protocols rather than bespoke glue. The result is a system whose state you can audit, because everything that changed it is written down and nothing is silently overwritten.
The self-improvement loop
The whole system is run as one loop: propose a single change to how it works, test that change against a real outside signal, keep it only if it wins, kill it if it loses, and archive the lineage either way. Improvement here is not a slogan; it is a procedure with a scoreboard, and the scoreboard is kept by something other than the part being graded. Nothing is banked as progress without a prediction that could have failed. A person sits on the top rung of that loop, always - approving what compounds and killing what does not.
How a single task moves through the machine
The parts above are not a static diagram. Every real piece of work runs the same path, and that path is the point:
- Orient. Before answering, the system loads its bearings - the memory store, the calendar and inbox, the working board, and whatever the task touches - so it starts from the current state of the world, not a stale one.
- Work. The substrate does the reasoning, drawing on the skills the task calls for and the context memory supplies.
- Verify. The result runs the harness - open the real source, check the record, and where it is an empirical claim, grade it against a signal fixed outside the model. Unverified work is labeled owed, not done.
- Checkpoint. Before leaving any task, the system writes down where things stand, so nothing is left in its head and completed work stays completed.
- Record. What happened is written to the append-only log, and the live views of state are regenerated from it.
- Harvest. At the close, verified learnings are routed up into memory and skills, and open predictions that have come due are scored - win or loss - against the artifacts they named.
The rules the whole machine is held to
These are not aspirations printed on a wall. They are the operating constraints the system runs under, and the reason the engineering can carry the word "honest":
- Cite, don't claim. Rented components are named as rented. We claim only what we built.
- Read the artifact, not the note about it. A summary, a filename, or a status flag is never accepted in place of the thing it describes.
- No progress without a losable prediction. Nothing is banked as a win unless it was staked on a claim that could have failed.
- A loss is called from outside. The system does not get to grade its own homework; the verdict comes from a signal it did not author.
- Report the reversals. When something we shipped turns out wrong, we retire it in public and record why.
What we do not claim
The honest edges
The grader is not yet fully independent. The hardest problem in a self-checking system is that the thing being graded and the thing doing the grading can be too close together. Making the external grader genuinely independent of the generator - a separate instance, a different model, or an outside oracle - is the single open frontier we name, not one we claim to have closed. When our own external checks have failed, we have recorded the failures rather than hidden them.
The organs are early. Autonomous operation is real but young. We describe each organ as what it does today, and no organ ships anything irreversible without a person.
The intelligence is rented. The reasoning engine is a commodity model we do not own and did not train. The value we claim is the machine around it, and we are precise about that line.
The honest bottom line
Strip it down and the claim is small and checkable: we rent a frontier model, and we built a disciplined machine around it - memory so it carries context, skills so it grows, a verification harness so it tells the truth, organs so it works unattended, a coordination layer so its state stays auditable, and a loop so it gets better at getting better, with a person on top. None of that is magic, and we never say it is. It is engineering, held to the same honesty as the science.
If you want to see the machine do real work, that is the frontier results. If you want the proposed theoretical foundation the project also pursues - held separately, and clearly marked as proposed - it is on the foundations page.