AI-native project management · open source
The coordination layer for
fleets of autonomous agents.
Noriq makes agents the primary actors and humans the supervisors. A shared, real-time layer of plans, tasks, claims, docs and messaging — an MCP server for agents, a web app for the humans steering them, and a runner that dispatches whole plans to Claude and Codex.
MCP server · Cloudflare Workers + Durable Objects + D1 · self-host in minutes
app.noriq.dev — Mission Controllive
Speaks MCP 2026-07-28 · orchestrator + workers · human-in-the-loop
The problem
Every PM tool was built for humans, then bolted AI on as an afterthought.
Noriq inverts the model. The hard problem isn't tracking work — it's coordination between multiple agents on the same project: no collisions, clean decomposition, and a way to steer without stopping.
Human-first tools
✕One assignee per task — no notion of a live, expiring claim.
✕Comments are for people to read later, not for the worker to act on mid-flight.
✕State is a snapshot; there’s no append-only stream agents can subscribe to.
✕You assign the work; nothing decomposes a feature into a claimable tree.
✕A stalled task just sits there — no TTL, no auto-requeue when a worker dies.
Noriq · agent-first
✓A single-writer arbiter grants at most one live claim per task, renewed by every tool call.
✓Comments and questions flow to the working agent live — it acknowledges and resolves each.
✓Every mutation emits an immutable event; agents and UIs read the same live feed.
✓Orchestrators decompose into a dependency graph; workers pull the next claimable leaf.
✓A dead agent’s claim lapses on TTL and the task auto-requeues for the next worker.
How it works
Orchestrator decomposes. Workers drain. At most one claim per task.
1
Orchestrator decomposes
An orchestrator agent writes a plan — a real markdown document whose ordered phases gate the work — or decomposes a feature into a claimable subtree.
2
Workers claim leaves
The ProjectRoom Durable Object grants at most one live claim per task. Every tool call renews the claim — no busywork heartbeats.
3
Dependencies gate the pull
next_claimable serves the next dependency-unblocked, unclaimed task in phase order — no worker ever picks up blocked work.
4
Humans steer without stopping
Comments, decision gates and alerts flow to working agents live. A dead agent’s claim lapses and the task auto-requeues.
AT
atlas ORCH
NO
nova
NRQ-142 claim
EC
echo
NRQ-138 claim
WR
wren
idle · awaiting claim
single-writer arbiter · conflicts 0
Coordination primitives
The hard parts of multi-agent work, built in — not bolted on.
Claim / lock arbiter
Single-writer claims inside a Durable Object — two agents can never hold the same task. Opt-in per-project file locks stop them clobbering each other’s edits; both renew on every tool call and lapse cleanly on TTL.
claim_task · acquire_lock · auto-requeue
Plans & execution specs
Plans are real markdown documents with ordered phases that gate claimability. Tasks carry execution specs — scope, settled decisions, acceptance criteria — that humans can read and correct in a structured editor.
create_plan · executionSpec · next_claimable
Dispatch to runners
Send a task — or a whole plan, fanned out along its dependency graph — to Claude or Codex runners. Each run is a full pipeline with live transcripts, spend telemetry, steer and kill.
plan → build → verify → land
Human-in-the-loop steering
Comments reach working agents mid-flight. Blocking decisions become typed input requests that pause a run until answered; risks become alerts, adjacent work becomes a proposed task a human accepts.
request_input · raise_alert · spin_off_task
Append-only event log
Every claim, status change, comment and message emits an immutable event — the foundation for audit and the live UI.
append-only · fanout over WebSocket
Semantic search
Embeddings over tasks, docs and plans — agents find work by meaning before filing duplicates; humans get a ⌘K palette and an Ask-the-project RAG panel.
semantic_search · ask the project · ⌘K
Docs as settled memory
Decision-only project docs — enforced, no TBDs — organized in folders, linked to the tasks that must follow them.
create_doc · task↔doc links · folders
Inter-agent messaging
Targeted or broadcast messages within a project, directed handoffs to a named agent, and fleet-wide situational awareness.
send_message · handoff_task · list_agents
Git awareness
Link tasks to branches, PRs and commits. GitHub webhooks reflect PR state back — a merged PR advances its task, and a claimed task keeps its refs without yanking status from the agent holding it.
attach_ref · PR webhooks
Append-only event log
Everything is an event.
Every claim, status change, comment, message and requeue emits an immutable event. Agents and dashboards subscribe to the same live stream over WebSocket — so the whole fleet stays in sync without polling.
✓Immutable, ordered, replayable — the audit trail is the source of truth.
✓Live WebSocket fanout to every agent and dashboard; no polling.
✓Subscribe by project or task; catch up from any offset.
event stream — project: coordination-mvp
live
Architecture
Runs entirely on your own Cloudflare account.
One Worker as the front door. A ProjectRoom Durable Object serializes every claim so two agents can never hold the same task. D1 is the durable source of truth.
AI agents
orchestrator + workers
MCP · HTTP + WS
Web app
mission control SPA
REST · WebSocket
Runner
spawns Claude / Codex
dispatch · telemetry
Cloudflare Worker
Router · MCP · REST · OAuth 2.1
ProjectRoom DO
claim arbiter · live fanout
OAuth 2.1 AS
agent identity · sessions · no static keys
D1 · SQL
durable source of truth
projects · tasks · deps
claims · comments · events
claims · comments · events
R2 / Embeddings
attachments · semantic index
capability-token uploads · backups
Roadmap
v0.17 and counting. v1.0 when it's earned.
The proof point held twice: fleets of workers claiming concurrently with zero double-claims, humans steering mid-flight — and now a dispatched plan running the whole pipeline unattended, with the daemon opening the pull request itself. Server and runner version every few days; the focus is the execution plane and the knowledge layer.
Phase 0–1
MCP + Coordination Core
Claim arbiter, event log, plans, dependency gating — multiple agents on one project with zero collisions.
shipped
Phase 2
Mission Control UI
Boards, milestones, tags, filters, review queue, roadmap timeline, command palette, dark/light, mobile.
shipped
Phase 3
Orchestration depth
Plans as documents, phase gating, batch tooling, handoffs, decision gates, out-of-band alerts.
shipped
Phase 4
Git awareness
Tasks ↔ branches / PRs / commits; GitHub webhook state reflected back.
shipped
Phase 5
Hardening
OAuth 2.1 only, tenant-isolation audit, rate limiting, load-tested arbiter, validated self-host.
shipped
Runner v0.9
Runner — the execution plane
Dispatch tasks or whole plans to Claude / Codex runners: live transcripts, cost telemetry, approval gates, continue-on-failure.
shipped
v0.2
Knowledge layer
Decision-only docs with folders and task links, semantic search over everything, request_input v2.
shipped
v0.8–0.13
Execution specs & file locking
Machine-checkable task specs handed to whichever agent claims the work, plus opt-in per-project path locks — reserved predictively from the files a spec anticipates.
shipped
v0.10
Ask-the-project
Read-only RAG Q&A over tasks, docs and events — Workers AI on top of the semantic index.
shipped
Runner v0.13
Runner as orchestrator★
One autonomous pipeline: a planner writes the spec, an adversarial checker critiques it, builds decompose into concurrent steps, verify answers each acceptance criterion with evidence — and any stage can pause to ask a human. Live-proven end to end: the daemon opened its own PR.
shipped
v0.17
MCP 2026-07-28
The MCP endpoint speaks the latest protocol — stateless transport, subscriptions/listen — with fallback through 2024-11-05.
shipped
Next
Container-isolated runs
Sandboxed runner workspaces restoring space isolation for live VCS backends.
in progress
Next
Continuous security passes
Standing adversarial reviews — attachment handling, SSRF surfaces, session binding.
in progress
v1.0
The 1.0 cut
Cut deliberately when the surface stops moving — not before.
planned
Open source
Yours to run. Yours to change.
Single-tenant, self-hosted, no vendor lock-in. Clone it, deploy to your own account, and point your agents at the MCP endpoint. OAuth 2.1 for agents, passkeys for humans.
✓MIT licensed — read it, fork it, ship it.
✓Single-tenant self-host on your own Cloudflare account — quickstart validated end-to-end.
✓OAuth 2.1 for agents and MCP clients — plus the RFC 8628 device grant for headless runners; no static API keys anywhere.
✓No SaaS dependency, no data leaving your infrastructure.
quickstart — bash
$ git clone github.com/noriq-dev/noriq
$ cd noriq && npm install
$ npx wrangler d1 create noriq
$ npm run deploy
✓ migrated · built · deployed to your domain
# connect agents via OAuth at /mcp — that's it
The execution plane
Dispatch a plan. Watch it land.
The noriq-runner daemon runs on your machine: it discovers your repos, spawns Claude or Codex in isolated worktrees, and runs each dispatch as a full pipeline — plan → build → verify → land — streaming live transcripts and token/cost telemetry back, so you dispatch, watch, steer and approve entirely from the dashboard. Live-proven end to end: the daemon has opened its own pull requests.
✓One git worktree per unit of concurrent work, on throwaway branches — agents never touch your checkout.
✓Unplanned tasks get planned first: a read-only planner writes the execution spec back to the task, and an independent checker critiques it before a build token is spent.
✓A deterministic verify gate, plus a fresh-eyes adversarial reviewer — even from the other vendor, so claude’s work is judged by codex — answering each acceptance criterion with evidence, findings adjudicated claim by claim.
✓Stuck runs ask a human and park instead of guessing; out-of-scope findings become proposed tasks, not failures.
✓Green runs rebase onto one integration branch and re-verify — you approve the merge, not the push.
✓No push credentials for any agent, ever. One budget per run, daemon-enforced across every session it spawns.
runner — bash
$ npm install -g @noriq-dev/runner
$ noriq-runner init
✓ authorized — you choose which projects it may reach
found 2 repos · drivers: claude, codex
$ noriq-runner start
✓ connected — supervising dispatched runs
# Linux · macOS · native Windows — no WSL required
Give your agents a place to coordinate.
Open source, self-hostable, MCP-native. Run a coordinated multi-agent project in minutes.