Professional
Entangle
A federated runtime for coding-agent organizations, with graph-governed authority, signed Nostr coordination, Git-backed artifacts and deterministic validation of the coordination paths.
Entangle models organizations of coding agents: humans, agents and services are nodes in a graph, and the edges say who may talk to whom, delegate, review and approve. A Host controls assignments and runners execute the nodes. The alpha implementation exercises federation through deterministic fixtures; those checks do not establish physical multi-machine operation or production readiness.
- Shape
- Self-hosted federated runtime, TypeScript monorepo
- Coordination
- Signed Nostr events
- Artifacts
- Git-backed, referenced rather than embedded
- Role
- Author
- Repository
- entangle-run/entangle
The problem
Agents doing work for each other need a way to know who sent a message, whether they were allowed to send it, what artifact they are referring to, and what actually happened, after the fact, from a record rather than from a log somebody has to trust.
That is not a new problem. It is the problem of a distributed system with untrusted participants, and the reason it feels new here is that the participants are non-deterministic.
What I built
A Host holds the authoritative graph state, runner trust, assignment and projection, and exposes it as an API. Everything else is a client of that one boundary: a browser operator console, a participant client served by running user nodes, a CLI for headless operation, and the runners themselves. Four surfaces, one source of truth: adding a surface is wiring rather than a second implementation of the rules.
Runners join through a trust flow, publish signed observations, and run either an agent runtime or a human-interface runtime: a person is a node in the graph like anything else, not an exception to it. Adapters cover OpenCode and external engines, and artifacts are handed between nodes through git.
Hard parts
Identity had to come from somewhere, and borrowing it has consequences. Every runtime node is identified by a Nostr public key and communicates through signed Nostr events. The recorded reasoning is that this gives a global identity with no registry, verifiable provenance on every message, and one transport that works for local and remote nodes alike.
The consequences are written down beside the decision, and the third one is the interesting one: external systems must bind their own principals to a node rather than reuse the raw Nostr key, so git authentication and commit signing stay separate credential surfaces. Otherwise a coordination key silently becomes a repository write key. Secret management and package portability become first-class concerns for the same reason: a package that carries key material cannot be shared.
Artifacts are references, not payloads. Git is the first artifact backend, chosen for version control, explicit diffs and a natural handoff between nodes. The constraint recorded with it is that git must not become the only conceivable backend, which is why the message protocol carries artifact references and the runner owns the local git operations. The cost is an indirection that a git-only system would not need.
Testing coordination independently of model behavior. The test fixtures replace model calls and external engines with a fake OpenCode, fake OpenAI-compatible providers and stand-in external engines, and exercise federation, user-node messaging, artifact handoff, deployment tooling and volume recovery without making model API calls. Live-provider behavior and physical multi-machine operation still require separate manual validation.