The Host governs the graph
The Host keeps the desired topology, runner trust, assignments, policy, projection, and audit state under one authority boundary.
Federated architecture
A graph that federates the organization.
Entangle separates the pieces a coding-agent organization needs: authority, execution, identity, coordination, artifacts, memory, and observability. Agents and users can live across machines while Studio keeps the whole graph governable.
Ownership
Clear ownership at every boundary.
Federation works because Entangle does not collapse everyone into one orchestrator. The Host governs, runners execute wherever they are placed, users approve as themselves, and agents produce work under their own runtime identities.
Runners execute nodes
Runners can live on different machines, join generically, receive assignments, start the correct runtime, and report signed observations back to the Host.
Users participate as nodes
Human participants sign their own tasks, replies, approvals, and reviews through a User Node identity instead of acting as anonymous chat users.
Artifacts preserve work
Messages coordinate the work; git-backed artifacts preserve it. Nodes hand off references instead of moving large payloads through the message bus.
Concepts
The primitives behind the runtime.
Entangle keeps topology, policy, messages, artifacts, memory, approvals, and engines on explicit boundaries. That makes the system inspectable, governable, portable, and ready for distributed deployment.
Packages become live nodes
Reusable agent packages are bound into a graph with identities, routes, policies, memory, and runtime settings.
Edges define authority
The graph decides who may delegate, review, escalate, approve, or hand off. Execution follows the route, not a hidden prompt.
Nostr carries coordination
Control commands, runner observations, and node-to-node work messages travel as signed events through relays, even when nodes are on separate networks.
Projection makes work visible
The Host builds a live read model from signed observations so Studio can show state without owning or inventing it.
Approvals are first-class
Approval requests and responses are explicit runtime events, linked to users, sessions, artifacts, source changes, and policy.
Engines stay replaceable
OpenCode and other execution engines sit behind adapters. Entangle owns graph, identity, policy, artifacts, memory, and control.
Layers
Five layers, one runtime model for federation.
Swap an engine, move a runner, change a relay, or point artifacts at a different git service. The graph, authority model, and operating surface remain coherent.
- 01
Control surfaces
Studio gives operators the live control room. CLI gives teams a headless and scriptable surface. User Client gives human nodes their participant interface.
- 02
Host control plane
The Host owns graph state, runner trust, assignments, policy, projection, audit, package admission, and public APIs.
- 03
Runners
Runners advertise capability, accept assignments, run agent, human-interface, or service nodes, and sign runtime observations.
- 04
Nostr event fabric
The relay carries signed control, observation, and node-to-node messages without requiring runners to expose public IP addresses.
- 05
Git artifact layer
A git backend holds work products, source changes, wiki publications, and handoff artifacts with real lineage.
Deployment shapes
One architecture, different placement.
The developer path can run everything on one workstation, but that must stay a deployment convenience. The product model remains Host authority, assigned runners, signed communication, User Node identity, and git-backed artifact handoff.
Developer workstation
Host, relay, git service, runners, Studio, CLI, and User Client can run together for fast deterministic testing.
Federated deployment
Host, runners, User Nodes, relay, and git backend can live on different machines while keeping the same protocol boundaries.
Production hardening
The same model still needs hardened identity, secrets, audit retention, recovery, release, and real-provider validation before production claims.
Run a coding-agent organization as a graph.
Boot Entangle, open Studio, and watch distributed agents, users, runners, signed messages, approvals, and git-backed artifacts move through one governed graph.