Professional
Entangle
A self-hosted federated runtime for organizations of coding agents: a permission graph, Nostr-signed coordination, git-backed artifacts, and deterministic tests that prove the plumbing without spending model API calls.
Entangle runs organizations of coding agents the way you would run a company: humans, agents and services are nodes in a graph, and the edges say who may talk to whom, delegate, review and approve. Runners execute those nodes wherever they happen to live, so the system is federated whether or not you deploy it across machines.
- 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
One agent doing work needs a good prompt. Several agents doing work for each other need something else entirely: 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 something non-deterministic. The non-determinism sits at the model boundary and nowhere else. So the deterministic paths run against 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 spending a single model API call. Live provider credentials and real engine behaviour remain manual validation, and the repository says so rather than implying the fixtures cover them.