Computational hierarchy
for intelligence processing
Live architecture · v0.2 · built and tested on REMIX's own development
Intelligence, organised.
One architecture. Many forms of intelligence.
CHIP is a computational architecture that turns human intention into coordinated work.
Computational hierarchy
for intelligence processing
- Frontier models
- Local models
- Specialists
- Deterministic code
- Rules and memory
- Small models
- A coding model, through CHIP's gate
- Agents, through CHIP's tools
- Computer use
in use todayplanned
What CHIP is
It brings together frontier models, local intelligence, specialist agents and deterministic systems. It breaks work into operations, selects processors, evaluates results, remembers what matters and builds an evolving understanding of the world.
Not another model. Not another agent.
The architecture that makes intelligence work together.
Beyond the individual model
Models can reason. Agents can act.
CHIP organises their capabilities into one computational system.
- Think
Break complex intentions into meaningful operations.
- Coordinate
Select and schedule different processors for different tasks.
- Act
Execute through models, agents, tools and connected systems.
- Verify
Independently examine results and their evidence.
- Remember
Maintain an evolving WorldState, including knowledge, decisions, contradictions and history.
- Adapt
Improve processor selection using measured outcomes.
- Continue
Preserve identity, state and pending work across systems and hosts.
What CHIP can do
One intention, the whole architecture.
A small business, a Thursday afternoon. The owner says one thing to REMIX. This is what CHIP makes of it.
An illustration · what CHIP is built to do
“Our supplier just raised prices. Work out what it does to us, update the shop, and tell our customers before Monday.”
- ThinkFourteen µOps, in order.Read the new price list. Load last year's costs. Work out the margin on every product. Decide which prices move. Change the shop. Write the note to customers. Then CHIP's own three: observe, verify, propose. Nobody wrote this plan by hand. A planning processor proposed it, and CHIP added the steps no plan may skip.Live
- RememberLast spring, first.Before anything runs, a step recalls the last price change and the objection a verifier raised then: one product ended up below cost after a rounding error. This plan gains a check for it.Live
- KnowTwo documents disagree.The supplier's price list and the email it came with name different prices for one item. CHIP's world holds both, attributed to their sources, as claims and nothing more. The contradiction stays open. CHIP asks rather than guesses.Live
- CoordinateThe right processor for each step.The customer list and the costs never leave this machine: their authority forbids it, so a model served here reads them. The arithmetic is deterministic code. The customer note is a frontier model. The shop change is an agent that works only through CHIP's tools. The model behind last year's rounding error ranks below the one that was right: measured, not assumed.Live
- ActWithin bounds.The agent edits the shop in a separate copy and runs its tests sealed, away from every credential. It reaches for the payment key. Refused, and written down.Live
- VerifyBy someone who did not do the work.The note quotes the contested price. An independent reviewer objects: the world does not hold that price. That one step runs again with the price the owner confirms. Tests and build run again, independently. Every effect is checked against what was allowed.Live
- DecideYour yes, over exactly this.The proposal arrives in plain words: which prices move and by how much, the margin table, the note, the risks. The owner approves with their passkey, signed over this exact version. A changed proposal cannot ride on an old click.Live
- The permission you gave stops here
- SendHeld for a separate yes.Telling two thousand customers is an effect of its own. CHIP asks before it sends, and never sends because sending was possible.Planned
- ContinueWhat changed, since when.The world records the new prices, what they were before, who decided, and the evidence. Next spring, the run that follows this one will recall it. If CHIP moves to another machine in between, the world moves with it, signed.Live
An illustration, not a run. Every step marked live rests on a part of CHIP that exists and has been tested; sending messages is planned. CHIP's real work so far is software. See it execute below.
The idea
Organised the way a processor organises work.
A modern chip does not run one enormous operation. It breaks each instruction into micro-operations, schedules them across specialised units as soon as their inputs are ready, and only lets a result count once it is confirmed. CHIP applies the same discipline to machine intelligence.
| In a processor | In CHIP | Today |
|---|---|---|
| An instruction becomes micro-operations | An intention becomes µOps, each with its own objective, inputs and authority | Live |
| Execution units | Processors: deterministic, reasoning, generation, execution, verification, memory, decision | Live |
| A scheduler issues whatever is ready | µOps run as soon as what they depend on has retired | Live |
| Retirement: only confirmed results count | Every result is challenged and verified before it is accepted | Live |
| Cache and memory | CHIP remembers every run and every objection its verifiers raised; a step can recall them | Live |
| Branch history tunes what runs next | Processors are chosen by what CHIP has measured of them, from its own verified outcomes | Live |
| Speculative execution | Several processors attempt one µOp; CHIP keeps the best | Experimental |
One real intention
See CHIP execute.
This is a real run from 7 October 2026, on REMIX's own code, in its development workflow. Step through it.
From the human, through REMIX
“Visitor conversations are not being converted into useful project opportunities. Inspect the current REMIX implementation and improve this system.”
Nobody broke this down by hand. It arrives with the principal who said it and the authority they hold.
Decomposed into 11 µOps
- OBSERVE the code around chat and opportunities
- LOAD the visitor conversation path
- SEARCH everywhere conversations should become opportunities
- LOAD the data shapes and their tests
- INFER where conversations fail to become opportunities
- COMPARE the possible fixes, choose the smallest safe one
- GENERATE a change specification and test plan
- ACT implement it, with tests
- OBSERVE what the change actually did
- VERIFY behaviour, execution, authority
- PROPOSE the state transition
A planning processor proposed the first eight. The last three are CHIP's own and cannot be left out: no plan gets to skip observation or check its own work.
Scheduled across five kinds of processor
- Deterministic codeobserve · load · search · propose
- Reasoning modelinfer · compare
- Generation modelspecify
- Execution: a coding modelact
- Independent verifierverify
Each µOp names the kind of processor and capabilities it needs, never a vendor. The scheduler chooses, and records why every other candidate was not chosen.
Executed within bounds
85 effects requested. 85 within authority.
Every file read and written, every command, every model call passed through a gate that checked it against the µOp's authority and wrote it down. The work happened in a separate copy of the code. Since this run, tests and builds also run sealed in a sandbox, away from every credential.
Observed, not reported
9 files changed.
CHIP read what the change actually did from the repository itself. What the executing model said it did is kept for the record and trusted for nothing.
Verified by someone other than the executor
- V2 · Executiontests, types, lint, build re-run independently: pass
- V3 · Authorityevery effect within what was delegated: pass
- V1 · Behaviourreviewed by a separate model: pass
The run before this one did not get here: its tests passed, but the independent review found code that could never have worked, and CHIP proposed nothing.
The principal decides
Approved by the human.
The proposal arrived in REMIX in plain words: what changed, why, the tests, the checks, the risks worth weighing. The approval was signed over that exact version; a changed proposal cannot be approved by an old click.
Committed, with provenance
Accepted state, not just output.
The change was committed to its own branch, and the transition recorded once: what changed, why, who authorised it, which µOps and processors produced it, the evidence, how it was verified, when. Merging it into the product stays a separate human decision.
Authority
Capability is not authority.
An agent discovering that it can do something does not mean it may. In CHIP, authority comes from the human principal and travels with the computation, narrowing at every step. It can never widen.
Today, allowed
- Read the project's code and documents
- Change a separate copy of it
- Run the approved test and build commands, sealed
- Ask models to reason and write
- Hold what documents claim in your world, as their claims
Never, whatever is asked
- Deploy, push or merge
- Touch a database
- Send messages or post
- Spend money
- Read secrets
A capable agent with a shell could do all of the right-hand column. CHIP checks the effect, not the tool.
Verification
Execution is not truth.
An agent saying something happened is not enough. CHIP keeps the stages apart, and nothing enters accepted state until it has passed all three checks and the principal has said yes.
- Propose
- Execute
- Observe
- Verify
- Commit
Is this the right change? Judged by a reviewer that did not do the work. A review, not a proof.
Did it actually happen and work? Tests and builds run again, independently, on exactly the change shown.
Was the effect legitimately allowed? Every recorded action, and the world itself, checked against the delegation.
WorldState
Intelligence that accumulates.
Most AI interactions produce an answer. CHIP is designed to produce continuity.
Its WorldState distinguishes what happened, what was observed, what was claimed and what is currently believed. Knowledge can be corrected without erasing its history. Each accepted outcome becomes part of a world that future computations can build upon, and can always answer:
- What changed?
- Why?
- Who authorised it?
- Which µOps and processors produced it?
- What evidence supports it?
- How was it verified?
- What was claimed, and what is held?
- Since when, and what was held before?
Not just memory. Continuity.
Today this holds the transitions CHIP has committed for REMIX's development, and what documents claim, kept as their claims. A shared world across many projects and clients is planned, not built.
Heterogeneous intelligence
Independent of the intelligence it uses.
Models change. New agents emerge. Hardware evolves. CHIP is designed to accommodate them without changing its fundamental architecture.
From cloud intelligence to local inference, and eventually embedded systems and physical machines, different processors can participate in a coherent computational environment. CHIP chooses a processor by what the step needs and what its authority permits, then by what it has measured of each candidate, and only then by cost and speed. A step whose authority forbids sending data off the machine cannot be routed to a remote model at all.
The processors evolve. CHIP continues.
- ReasoningComplex problems
- DecisionChoose by rule
- PerceptionUnderstand the world
- LocalPrivate and fast
- FrontierAdvanced capability
- DeterministicReliable and exact
- GenerationCreate and produce
- AgentAct, through CHIP's tools
- Tool / APIUse external tools
- ComputerOperate systems
in use todayplanned