Trade finance & documentary credit
Obligations gated by document conformance, time-bounded rights, scoped forfeitures; grounded in our statute-based research on letters of credit.
The model proposes.
The substrate decides.
Neutrino is building the coordination fabric for the agent economy: a verified symbolic substrate that lets organizations' AI agents negotiate, contract, fulfill and settle with each other — without either side having to trust the other's models with state, authority, or money. And not only agents: the same substrate coordinates people, services, and existing systems under one verified agreement.
Write a coordination agreement once. Compile it into a fail-closed, content-addressed plan. Bind it to your runtimes and your models through a governed binding contract. Admit evidence by policy. Probabilistic model behavior is never load-bearing for multi-party state.
Project status Research infrastructure with a working coordination compiler; the console/platform surface is in development; current work is the pre-registered research program.
Where this is going
The coordination fabric for the agent economy
The next economy is agents transacting with agents — across company boundaries, at machine speed. That economy has a missing layer: today, nothing below the models themselves can be trusted to hold the state, enforce the obligations, and settle the value of a multi-party agreement. Prompt engineering is not a security boundary, and no amount of model scale makes a counterparty's model trustworthy.
The target picture Neutrino is built toward:
- A coordination agreement is a sovereign object — authored once, compiled to a verified plan, content-addressed, and executable by every party because its vocabulary is closed and verified.
- Each organization binds its own slots: its services, its people, its models — of any size, including small local ones — under roles and assurance tiers it controls.
- Agents propose, negotiate and produce work; the substrate admits their outputs as evidence under policy, fires only authorized effects, enforces every window and deadline, and settles on the rails each party chose.
- Two organizations that have never integrated execute a new agreement the day they sign it — the dynamic sovereign mode: per-agreement, peer-to-peer, no shared platform required.
- The economics invert: because protocol discipline lives in the substrate, the models can be small, cheap, and local — our pre-registered hypothesis is that this collapses the cost of coordination-heavy agent work while making its guarantees stronger, not weaker.
The design principle underneath all of it: the model proposes; the substrate decides.
And a word for the emerging profession: harness engineering is becoming a discipline — our bet is that most of a harness should be compiled, not engineered. With Neutrino, the harness engineer becomes a coordination author: declare the agreement and its acceptance policies; the substrate runs the harness.
The runtime
How a coordination runs, as designed
One agreement instance, end to end:
-
1
Author
Today: a
.neuagreement. Target: proposed from versioned domain ontologies — model-assisted, verifier-admitted; the model never owns the reduction. -
2
Compile
The agreement becomes a verified, content-addressed plan — or a refusal. Fail-closed, no partial semantics.
-
3
Bind
Each party's binding manifest maps its slots to concrete capabilities — an EVM contract, a SQL procedure, an internal service, a human approver, an LLM — with roles, runtimes, and assurance tiers. Binding is governed and validated; an unauthorized binding never runs.
-
4
Run
Obligations become eligible when their predicates hold. Bound capabilities are invoked — in the target design, with context the substrate projects deterministically from the plan: one obligation, its typed inputs, its acceptance criteria.
-
5
Admit evidence
Model and oracle outputs enter as evidence under acceptance policies — quorum, observer independence, deterministic verifiers. Effects fire only on accepted evidence.
-
6
Settle
Value effects execute on the bound rails — balanced, replay-safe, at-most-once — on Solidity/EVM and PostgreSQL today, further rails by profile.
-
7
Enforce time
Windows and deadlines fire in the substrate — a missed deadline forfeits exactly its scoped ground, with no model in the loop.
-
8
Observe
Every obligation's status — eligible, fired, refused — is a typed observation, projected per participant view. The console (in development) is the human surface over exactly this.
Status honesty in one line
Steps 1 (.neu), 2, 3, 5, 6, 7 and the typed observations of 8 are shipped;
ontology-first authoring, substrate-projected model context, and the console surface are
in development or pre-registered research — see the roadmap.
Where it applies
One substrate, many networks
The same substrate, wherever multiple parties must coordinate work and value without shared trust. Agents are the newest participants, not the only ones — most of these applications run with humans, services, and existing rails as first-class participants today:
Supply chain & logistics
Milestone-gated payment legs, independent-observer evidence, custody transitions.
Payments, marketplaces & settlement
Escrow, net settlement, promotions, installment flows: our compiled example corpus today spans more than two dozen such coordinations, each lowering to both rails.
Machine-to-machine / agent commerce
The category bet: agents contracting with agents under sovereign agreements, evidence-gated and settled by construction.
Decentralized compute & AVS coordination
The beachhead segment: post-handshake coordination for networks that already have matching and need enforceable fulfillment and settlement.
Regulated, evidence-heavy processes
Clinical-grade verification flows where every acceptance must be attributable and auditable.
Each application reads the same way: the substrate owns state, evidence admission, time and settlement; the agents do the semantic work; neither side trusts the other's models.
Where we are on the road
Shipped is the proof of execution
Shipped the proof of execution
- An MLIR-based coordination compiler: agreements compile to a verified typed plan and lower to two target rails — Solidity/EVM and PostgreSQL — with byte-stable outputs and cross-backend equivalence checks.
- Verified plans with content-addressed identity: fail-closed validation, replay/idempotency obligations, M-of-N evidence acceptance, authorization topology, participant-scoped views.
- A provisional closed operator algebra for coordination — obligation, conformance, independence, temporal validity and forfeiture — with reference evaluation.
- A published, digest-pinned core contract bundle with an external pack verifier: domain packs validate against the bundle alone (production-pack extraction in progress).
- Engineering discipline on named critical surfaces: fail-closed gates with executable mutation probes, byte-golden outputs, and a gate-integrity meta-check that pins the gates themselves.
In development
- The obligation algebra's first compiler realization through the backends.
- Domain externalization at scale — domains as independently versioned, published packs.
- The console: the observation and operations surface over running coordinations.
In pre-registered research
- Ontology-first authoring — the model proposes typed domain interpretations; deterministic reduction and verification decide.
- The agent executor — substrate-projected context per obligation; evidence-gated model invocation.
- The economics: harness-overhead reduction and small-model sufficiency, under matched-arm, pre-registered experiments. Negative results are first-class outcomes.
Everything in the shipped list is enforced by construction, by executable checks, or — for review practice — evidenced in the public record. Claims beyond it are labeled hypotheses, and we test them in public.
The problem, precisely
Why coordination can't live in the model
The harness tax. Much of agent computation goes to state recap, retries, self-verification and coordination narration rather than the task itself — bookkeeping on the most expensive, least reliable substrate available: stochastic tokens. (Practitioner observation; our own measurement is a deliverable of our pre-registered experiments.)
Reliability by scale is costly. Frontier models are used for agentic work in large part for protocol discipline; that discipline is bought with tokens and still fails probabilistically.
No cross-org trust story. When two companies' agents transact, neither can rely on the other's model — regardless of its quality.
A widespread answer is imitation: make models reliable enough to be trusted with coordination. Neutrino's answer is containment — a boundary formalized in both directions:
| Direction | Mechanism | Meaning | Status |
|---|---|---|---|
| Neural → Symbolic | Attestation / acceptance policies | A model's output is evidence, admitted by policy. Effects fire only on accepted evidence. | Shipped |
| Symbolic → Neural | Selection-manifest context projection | The substrate assembles each model call's context deterministically from the verified plan. | In research pre-registered |
An ineligible effect does not fire. Unaccepted evidence does not propagate. The model's inaccuracy is not load-bearing.
Research & discipline
The diligence layer
We pre-register hypotheses and experimental designs before measuring; numeric claims about model-size sufficiency, cost collapse, or harness-tax reduction remain hypotheses until experiments report.
What we claim, what we hypothesize, what we don't claim
| Proven within the modeled system, under recorded assumptions | Hypothesized pre-registered, numbers pending | Not claimed |
|---|---|---|
| Coordination invariants hold by construction: at-most-once effects, fail-closed authorization, deadline disposition, evidence-gated effects | The magnitude of token/cost reduction; small-model sufficiency thresholds; context-projection quality gains | That outcomes are "absolutely reliable" — semantic evidence quality is bounded by the acceptance policy, not proven |
| Two target backends from one verified plan; byte-stable, hash-pinned artifacts | The symbolic → neural projection boundary and presentation-profile gains | That the harness-overhead share is our measurement (it is cited practitioner observation) |
| The neural → symbolic boundary: evidence admission by policy | Break-even traffic volume for specialized models | That quorum over same-model instances is independent evidence — diversity is required and measured |
The guarantee boundary what each layer owns — and does not
| Layer | Responsibility | Does not guarantee |
|---|---|---|
| Model | Proposes an interpretation | Semantic correctness vs human intent |
| Ontology / domain schemas | Preserve domain meaning + provenance | Real-world truth of external facts |
| Reduction verifier | Proves the proposed mapping is allowed | That the interpretation matches the speaker |
| Semantic kernel | Validates representable coordination invariants | External oracle correctness |
| Target profiles | Lower or refuse | Business-level correctness of original intent |
| External systems | Real-world truth and evidence | — |
Active pre-registered work: executor context custody & harness economics · neuro-symbolic bottleneck & agent economics · kernel adequacy (GO/NO-GO). (Full public summaries: the /research page.)
Contact
Research contact / early access
Research, grant, and investor conversations.
[email protected]Research plans: public summaries