A small, restartable core with defined connection rules. MCP tools, A2A agents, SKILL.md skills, and the components no standard covers — memory, workflows, surfaces — plug in, combine, and can be removed without the system going down. We adopt the standards; we build the layer that runs them safely.
MCP, A2A, SKILL.md and the rest define how agents and tools talk. No one ships the layer that makes a heterogeneous system of them safe to run together — contained, guarded, health-checked, and restartable on one machine.
MCP (tools), A2A (agent-to-agent), SKILL.md (skills) — open and consortium-governed. They specify messages.
A neutral core that is not an agent, not a vendor, not a product — it runs the protocols with teeth.
Function is the combination. The core does not think, remember, or act — it lets things that do, do so safely, whatever standard they speak.
Signals cross the core with deadlines and delivery semantics. Components speak their own standards — the core connects them without owning any.
Every connection carries a scope — what this component may read, do, and reach. The guard enforces grants, expiry, revocation, and the core's delegation law: authority passed on can only shrink. Delegation is not an add-on — it is enforced here, in the core.
Which components are registered, healthy, degraded — and when something must be treated as gone.
We adopt the open standards — and we build the pieces no standard covers: the missing protocols, the sovereign world, and the layer that runs everything safely on one machine.
No cross-vendor, owner-controlled memory standard exists. We publish one: read, write, search, update, expire, snapshot — with declared durability and evidence roles. MCP's resources are read-only; memory that outlives sessions needs a real protocol.
Runs that survive their process — and irreversible actions that persist intent, expose unknown outcomes, and reconcile reality before retrying. No duplicate payments, publishes or sends.
One machine, many principals: each gets a private world no one else can read. Shared worlds exist only by agreement, with roles and quorum. Nobody has ever shipped this for agent systems.
Every consequential action leaves a record you can read: who allowed it, what it touched, what happened — with observed facts kept apart from agent reasoning. "Why did you do that?" is answered from the log, not guessed by the model.
One agent can hand a bounded slice of its authority to another — scoped, with an expiry, a purpose, and a depth limit — but the receiver never gets more than the giver holds. Revoke the grant and the whole chain dies at the next check. Swarms can form; they can never out-power their principal.
Extensions to adopted standards are additive and optional — unmodified community artifacts keep working. Everything we create is a public, versioned spec; the baseplate is what lets a heterogeneous system — different standards, different vendors, different models — run on one machine without breaking each other.
If it speaks a standard — MCP, A2A, SKILL.md, or one of ours — it joins, from any author, now or in ten years.
Every component declares what it does and what it needs. The core grants a subset — nothing more.
Removal is a legal operation. The core keeps routing; only that component's connection stops.
One broken or hostile component fails alone — one containment group per component, bounded resources.
The guarantee is structural: the core holds no content and no component logic, so it has nothing that can corrupt the combination. Continuity is preserved by what the core does not contain.
If it cannot survive that and hand every private world back exactly as it was — it does not ship. This is the acceptance test of Phase 3.
Combinations are built by many independent suppliers, not by the platform owner. The neutral layer — not the best product — is where the ecosystem settles. That layer is what we build.
The architecture is designed and built in the open — with the community that will steward it. The full DAO design (credentials, economy, governance, roadmap) is in the ResonantDAO whitepaper.
Before one line of code ships, we want the strongest minds on the rules, the core boundary, and the guarantee. Build and test with us — the architecture is discussed in the open, the tech team is forming now.
discord · resonantdao · augmentatism — the whole stack, one community