Developer proof

Run the current runtime path.

Entangle is pre-release, but the core operating path is runnable: Host, relay, runner registration, runtime assignments, user-node interaction, deterministic agent execution, artifact refs, Studio, and CLI.

Host

Graph authority, runner registry, assignments, projection, and APIs.

Relay

strfry Nostr relay for signed coordination events.

Runners

Generic node executors that join and receive assignments.

User Client

A participant surface for a running human node.

Studio

Admin control room for graph, state, runners, and audit.

CLI

Scriptable surface over the same Host projection.

Fast path

Verify the system without real LLM credentials.

The fastest useful proof keeps the deployment compact while preserving federated boundaries. It uses fake OpenCode/model responses by design so CI and local smoke tests are deterministic.

Host API defaults to localhost:7071
Relay defaults to ws://localhost:7777
Studio is optional for the smoke path and available for manual inspection.
install + verify
$ git clone https://github.com/entangle-run/entangle.git
$ cd entangle && pnpm install --frozen-lockfile
$ pnpm verify
start relay
$ docker compose -f deploy/federated-dev/compose/docker-compose.federated-dev.yml up -d strfry
run deterministic proofs
$ pnpm ops:demo-user-node-runtime:fake-opencode
$ pnpm ops:smoke-federated-process-runner:fake-opencode

What this proves

A compact deployment, not a local-only architecture.

Running everything on one workstation is a convenience. The proof still exercises Host APIs, relay-backed events, runner assignment semantics, user-node signing, engine boundaries, and artifact references.

Start the relay

The compact developer path uses a reachable local relay, but the runtime still treats it as an external coordination service.

Run a User Node

The user-node runtime signs launches, replies, and approvals with stable graph identity instead of acting as the Host.

Run the fake OpenCode proof

The fake endpoint gives deterministic agent output so the end-to-end path can be checked without paid LLM credentials.

Inspect artifacts

Outputs are materialized through git-backed artifact refs rather than large Nostr payloads.

Manual validation

Real providers are the next operator test.

The runtime can be connected to real OpenCode/provider credentials, but the public proof path intentionally avoids depending on external LLM APIs. Real coding tasks with real provider calls, commits, and PRs should be validated by an operator with the desired credentials and repository access.

See status
Federated Entangle organization graph An example Entangle organization with a User Node, Planner Agent, Builder Agent, Nostr Relay, and Git artifact backend distributed across multiple machines. Machine A human interface runner Machine B agent runner Machine C agent runner brief task plan handoff status push ref review ref User Node signed human Planner agent node Builder agent node Nostr Relay signed messages Git artifact refs

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.