LLM-agnostic · local or distributed actors

Orchestrate AI workers wherever they run

Bring Claude Code, Copilot, custom MCP servers, or any LLM-backed worker. Run parallel actors locally on one machine or distribute them across laptops, CI, and private networks.

Workers matched 8

Governed gates 3

Events tailed 142

planner session rank workers batch delegate dashboard digest

local implementer remote verifier CI reducer loop controller

questions approvals artifact manifest event replay recovery

Steer run Approve Answer Abort

Exact process

How a run moves through NFLTR

NFLTR is the control plane around agent-authored work. Your planner and workers make domain decisions; NFLTR carries the task graph, governance, status, and recovery path for both local actor teams and distributed fleets.

1
Attach a planner
Start nfltr mcp with an API key. The planner publishes task digests and polls the command queue from nfltr.xyz.
2
Register workers by role and capability
Workers can wrap Claude Code, Copilot, custom MCP servers, repo-local tools, or service agents. Labels capture role, model family, repo access, platform, capacity, and locality so the planner can probe and rank them.
3
Decompose and delegate
The planner turns a goal into child tasks, dispatches one task or a batch, and keeps lineage so the dashboard can show root, child, and verifier state.
4
Steer work while it runs
Operators answer worker questions, approve gated dispatch, reject unsafe work, or abort tasks through the same command queue.
5
Verify, rework, reduce
Verifier, reducer, collector, and loop-controller agents record explicit outcomes. NFLTR stores the loop state without inventing the decision for them.
6
Observe and recover
The relay stores live digests, event tails, result summaries, artifact manifests, and recovery metadata so stalled or resumed work remains inspectable.

Problems solved

Use it when one agent session is not enough

Large code changes

Split work without losing the root objective

Fan out implementation slices, keep parent/child lineage, and bring verifier results back into one run.

Local multi-actor runs

Separate builders, reviewers, and reducers

Run planner, implementer, verifier, and reducer actors on one machine to validate coordination before moving any worker to another host.

Human gates

Keep approvals and questions in band

Workers can stop for input, policy can require approval, and the dashboard can answer or reject without restarting the run.

Distributed machines

Use the right worker where it already runs

Route work to laptops, CI hosts, private repos, or specialized environments by labels, reachability, and capacity while keeping one observable task graph.

Long-running work

Recover after disconnects and restarts

Task digests, event history, and recovery metadata keep state visible when a worker or planner goes away and comes back.

Audit and artifacts

Know what happened, not just final text

Persist status, events, result summaries, artifact manifests, approval state, and reviewer annotations for later inspection.

Use cases

Where local and distributed orchestration win

Use local nfltr orch when coordination quality matters more than machine count. Use distributed orchestration when the best worker is defined by repo access, hardware, network, secrets, platform, or availability.

Local nfltr orch

Better than a single agentic harness

Builder and verifier separation One local actor implements, another reviews with a clean context and reruns tests before the reducer accepts the patch.
Parallel investigation of one failure Run separate actors for reproduction, code archaeology, candidate fix, and test coverage, then merge the evidence into one decision.
Model and tool comparison Ask Claude Code, Copilot, and a custom MCP-backed worker to solve the same slice locally while NFLTR preserves task lineage and outcomes.
Human-gated local work Keep questions, approvals, aborts, and rework requests in-band instead of losing decisions inside one long terminal transcript.

Distributed nfltr orch

Useful when locality matters

Private repo or secret-bound work Route tasks to the machine that already has the checkout, credentials, internal network, or customer environment.
Heavy builds and specialized hardware Keep the planner lightweight while workers on CI, GPU hosts, or beefier desktops run slow builds, tests, traces, or benchmarks.
Cross-platform verification Dispatch the same change to macOS, Linux, and Windows workers so platform-specific failures appear in one orchestration graph.
Long-running or shared operations Let teammates monitor, approve, recover, or resume work from the dashboard when a laptop sleeps or a worker reconnects.

Workflow

Plan, dispatch, observe

Use the CLI to attach planners and workers, then keep the run visible in the hosted dashboard.

Register the planner

Connect your local planner process to the hosted control plane and publish live task digests.

nfltr mcp --proxy-url https://nfltr.xyz --write-mcp-json .vscode/mcp.json

Where to start

Choose the surface that matches your job

New setup Install and register Bring up a planner, create an API key, and connect the first worker. Live run Open the dashboard Inspect task graphs, approvals, activity, agents, and API keys. Local dev Run it locally Use a local auth shim, seeded API key, and protected APIs to improve the UI safely.