ORIAS / Chimera

Software has spent decades waiting to be changed.

For most of that time, people did the changing. We gave them better languages, compilers, debuggers, version control, tests, deployment systems, and steadily better tools for understanding what they were working on. Now we are giving them models that can read a repository, reason about it, and increasingly do meaningful engineering work themselves.

The tools that change software have become remarkably capable. The software itself has remained mostly passive.

A mature codebase may have lived through years of decisions, migrations, incidents, failed approaches, production discoveries and architectural constraints. An engineer learns some of this. A model learns some of this.

Then the engineer leaves. The session ends. The model changes. A surprising amount has to be reconstructed.

Chimera is persistent engineering intelligence for software.

When a repository enters Chimera, Chimera begins establishing an evolving software world around it. It builds and maintains the most complete picture it can of the files, symbols, interfaces, dependencies, tests, commands, and runtime behavior; of the engineering transitions the code has been through; of the failures and the evidence behind past decisions; and, explicitly, of what is still unknown. The result is not a snapshot. It is a world with a past: what changed, what was tried, what was settled, and what is still open.

It does not claim to understand everything. It records what it can establish, marks what it cannot, and keeps the whole picture current as the software changes. A map that is not updated becomes a lie, so staying current is not a feature of the world — it is the definition of it.

Everything in Chimera belongs to one loop. A world records what is true now. Understanding holds what is known, what has been learned, and what remains uncertain. An act changes something — a person, a model, or a tool. Observation records what actually happened. Verification establishes what the evidence supports. Learning decides what should persist, and feeds it back into the world.

Most AI coding systems put the model at the center. The model is the intelligence, the harness turns its output into file changes, and the repository is what gets operated on. When the session ends, whatever the model understood is gone, and the next session starts again from nothing.

Chimera inverts this. The software is at the center. The repository — its structure, history, behavior, and evidence — is the persistent boundary of intelligence. Humans, frontier models, local models, specialists, and future cognitive systems arrive and leave. The software world remains.

The model can leave. The lesson shouldn’t.

Models come and go. The world compounds.

Chimera retains useful engineering experience. It keeps:

• how the system actually works
• what was tried before
• what failed, and why
• what the evidence supports
• what is still unknown
• what should matter next time

A mature repository becomes easier to engineer tomorrow because of work performed today.

A change can be compared against a failure from months earlier: when a migration begins to recreate a condition that has already caused an incident, the mechanism is on record, and so is the evidence that was missing the first time.

Some mistakes should only happen once.

A failure kept only as a story protects nothing. A failure kept as a mechanism — the conditions under which it happens, plus the evidence that reproduced it — can be recognized before it is recreated.

A serious migration, investigation, or large refactor may last hours or days. It should not depend on keeping one chat alive.

Chimera preserves the objective, the state of the world, the state of the work, the evidence, the failed attempts, the uncertainty, and the decisions. A model can stop. Another can continue. A person can intervene. The work remains coherent.

There is a doctrine at the center of Chimera, and it can be stated plainly: the system that changes the software does not get to certify itself. Proposal, execution, observation, evidence, and settlement are kept separate. A model reporting that work is complete is not sufficient evidence that it is. The change is run, checked, replayed, compared against its claims, and settled by a layer that did not do the work.

Unknown is allowed. Failed tests are allowed. What is not allowed is an unsupported claim becoming persistent knowledge.

Memory is not automatically truth.

The point is not suspicion. It is that a claim and the evidence for it are different things, and a system that cannot tell them apart will eventually believe its own guesses.

This is not bureaucracy. It is the difference between a system that accumulates guesses and one that accumulates knowledge.

Chimera is also intended to explore possible software futures. A risky migration, refactor, or optimization may have several candidate outcomes. Where it is technically possible, Chimera can branch alternatives, execute or simulate the relevant parts, compare consequences — including against doing nothing, and including rollback — measure the evidence, reason about uncertainty, and recommend the strongest option.

It cannot predict the future. This is an active research direction, not a finished capability. But the question it asks is concrete: before you commit to one future, see what the others would have done.

Chimera is not one giant model. Different problems call for different intelligence. Exact facts can be deterministic. Repeated work can become a procedure. A narrow recurring problem can become a repository-specific specialist. Some capabilities can run locally. Novel problems can use frontier models. And sometimes a human remains the correct authority.

The goal is to use the cheapest reliable intelligence appropriate to the problem. When reasoning stabilizes and stops changing, it should stop being paid for at frontier prices every time.

Useful reasoning shouldn’t have to be paid for twice.

An actor working inside Chimera becomes increasingly adapted to the repository through context, history, procedures, tools, routing, specialists, local models, and learned adapters — and, where future research justifies it, training or fine-tuning.

But no individual model owns Chimera’s intelligence. Claude, Codex, local models, specialists, and future actors are all replaceable. The durable asset is the world and the intelligence surrounding the repository. This is deeper than a dropdown that lets you choose a model. The model is an instrument, not the identity of the system.

The model is replaceable on purpose. Whatever actor is present — a frontier model, a local model, a specialist, or a person — it works against the same world and the same evidence. That is what makes the accumulation durable: it is not stored inside any single mind that can be swapped out.

Chimera is not only for one engineer. Across a team, several humans and AI actors contribute to the same persistent software world. Useful understanding becomes institutional knowledge instead of being fragmented across individual minds, temporary model sessions, chat history, pull request comments, incidents, and Slack.

Different roles see different projections of the same underlying world. An engineer sees task-local context. A lead sees recurring architectural problems, uncertainty, and historical constraints. Engineering leadership sees grounded views of risk, blockers, repeated work, and system health. It is the same world. Only the projection differs. The point is institutional knowledge: understanding that stays with the software and the team, rather than leaving with whoever happened to be in the room.

Persistent does not mean expensive. It does not mean frontier models running constantly. Cheap deterministic systems can continuously maintain state, events, ontology, indices, identity, and evidence. Expensive cognition wakes only when it is actually needed. The world stays current for the price of a database, not the price of a frontier model.

Keep the world alive. Wake the intelligence you need.

The long-term direction is software accompanied by a persistent system that accumulates more of the intelligence required to understand itself, protect itself, test changes, remember useful experience, explore alternatives, and eventually participate in its own governed evolution.

To be clear about what this is not: it is not sentience, not consciousness, not software quietly rewriting itself, not uncontrolled self-modification. It is persistent, stateful, evidence-bearing, experimentally inspectable, and eventually capable of bounded adaptation under explicit authority.

We call the direction this points in the Living Repository.

Not software that magically writes itself. Software that accumulates more of the intelligence required to understand, protect and change itself.

Autonomy does not lower the standard. A change proposed by the system faces the same evidence and the same authority as a change proposed by anyone else.

It still has to prove it.

We keep the difference between what exists, what is being built, what is being tested, and what lies further out deliberately sharp. “Does” means demonstrable today. “Being built” means engineering underway. “We are testing whether” means an open experiment. “Further out” means a direction the earlier layers are built to reach, not a claim about today.

We’re interested in what happens when it can begin to participate.