Ship routine engineering with the lights off.
Nox Kit is an open-source dark software factory. AI agents take tickets from Jira, Linear, GitHub or Slack through your pipeline: spec, code, tests, review, release. People step in only where you ask them to.
Point at or tap a step to see what happens there.
People on 5 gates: Spec, Design, Review, Approval, Production
A person signs off at every gate. Good for the first week on a new repo.
Nox Kit runs the delivery line around your coding agents. You decide where a person has to say yes.
You describe how work gets done: pipelines, agents, models, budgets and the gates that need a person. The factory takes tickets through that line and records every step, with its prompt, its output, its cost and who approved it.
Each project has an autonomy level. Start assisted, with a person at every gate. When judge scores and escaped defects hold up, move to supervised, then to dark. If defects start getting through, the autonomy guard steps the project back on its own.
- Self-hosted
- One machine with Docker runs the whole stack. Code, prompts and traces stay inside your network.
- Your models
- Anything behind an OpenAI- or Anthropic-compatible API. Mix vendors, so one model writes and another reviews.
- Real costs
- The gateway meters every call. Budgets stop runs before they overspend, and the month is forecast at the current pace.
The factory asks before risky changes ship
When a gate's risk is above your auto-approve policy, the request lands in the approvals inbox and in Slack or Telegram.
You approve from the request itself: it carries the judge scorecard, the reviewer's notes and the diff stats. Reject with a comment and the work loops back to Build, and your comment becomes a proposed lesson for the agents.
You can also take a step over, do it by hand and hand the run back to the line. A gate that waits past its SLA pages whoever is on call.
Retry failed webhooks with backoff
Stopped for a person: touches db/migrations/
Sent to Slack, Telegram and the approvals inbox
How it's built
Each part runs as its own process and scales on its own. Configuration lives in Postgres, versioned with draft and publish, and exports to YAML.
Trackers and chat
Jira, Linear, GitHub, Slack, Sentry
Webhook intake
Signed, deduplicated, fanned out over Redis Streams
Orchestrator
Pipelines run as Temporal workflows that survive restarts
Step workers
Agent steps, rules, judges, policies and human gates
Sandbox per run
One container per run, Docker or Kubernetes
LLM gateway
Routing, metering, budgets
MCP gateway
Tools by allowlist
Beside the line: the API and command center, where every change is an audited action, and state in Postgres, Redis Streams and S3-compatible storage.
- Agent runtimes
- OpenHands, Claude Agent SDK, Claude Code, Codex CLI and Gemini CLI, picked per agent and overridable per step. A simulated runtime does dry runs without model costs.
- Stack
- Python 3.12, FastAPI, Temporal, PostgreSQL 16, Redis Streams, S3-compatible storage and LiteLLM. The command center is React and TypeScript.
- Plugins
- Step executors, task sources, chat adapters, sandbox providers and preview environments register as Python entry points with their own settings schema.
Rules every run obeys
- Budgets
- Per task, agent, client and month. When one runs out, new runs stop and the step says which budget it hit.
- Protected paths
- Migrations, auth, infrastructure or any path you list always wait for a person, even on dark.
- Agent permissions
- Shell, network, repository write and secrets are granted per agent. Without network, a sandbox reaches only the two gateways.
- Kill switch
- Pauses every run in the installation at once. Resuming picks each run up where it stopped.
- Roles
- Owner, admin, reviewer, operator and read-only stakeholder, with a permission matrix you can edit.
- Audit log
- Every action, approval, override and configuration change, with who made it and when.
Measured from every run
The same runs feed lead time and throughput, the four DORA metrics, cost per task by model and agent, and judge scores with first-pass rate and escaped defects. The hands-off rate shows how much went through without a person, and why the line still stopped.
Rises from 6% in week 1 on assisted to 86% in week 12 on dark.
| Week | Autonomy level | Hands-off rate |
|---|---|---|
| 1 | Assisted | 6% |
| 2 | Assisted | 11% |
| 3 | Assisted | 14% |
| 4 | Assisted | 17% |
| 5 | Supervised | 44% |
| 6 | Supervised | 51% |
| 7 | Supervised | 56% |
| 8 | Supervised | 61% |
| 9 | Dark | 76% |
| 10 | Dark | 82% |
| 11 | Dark | 79% |
| 12 | Dark | 86% |
Pipelines for content, support and data too
Each pipeline has its own stage names and starts from a template. Amber marks the step that waits for a person by default.
Engineering
- Spec
- Design
- Build
- Verify
- Review, waits for a person by default
- Release
Content
- Brief
- Research
- Draft
- Fact-check
- Edit, waits for a person by default
- Publish
Support
- New
- Investigate
- Answer
- Check, waits for a person by default
- Sent
Data
- Request
- Model
- Validate
- Review, waits for a person by default
- Ship
Integrations
Work comes in from trackers and alerts, approvals happen in chat, releases go out through your deploy tools, and agents reach other systems through MCP. Trackers sync both ways.
- Jira
- Linear
- GitHub
- GitLab
- Sentry
- Slack
- Telegram
- Argo CD
- Vercel
- Netlify
- Cloudflare
- Vault
- OpenRouter
- MCP servers
- Webhooks
Run it locally
Docker brings up PostgreSQL, Redis, Temporal and MinIO. The command center starts in simulation mode, so you can watch a factory work before connecting a repository.
# get the code
git clone https://github.com/makeagentic/noxkit
cd noxkit
# postgres, redis, temporal, minio
docker compose -f deploy/compose.yaml up -d
# command center on http://localhost:5173
cd frontend && npm install && npm run devFAQ
What is a dark software factory?
A dark software factory is a delivery system where AI agents do routine engineering work end to end, from ticket to production, without a person at every step. The name comes from lights-out manufacturing: plants that run with the lights off because nobody needs to be on the floor. People still set the rules, own the risky decisions and get pulled in when something needs them.
Is Nox Kit open source?
Yes. Nox Kit is released under the MIT license. You run it on your own infrastructure, point it at your own repositories and model providers, and nothing leaves your network unless you configure it to.
Which AI models and agents does it work with?
Any model behind an OpenAI- or Anthropic-compatible API, routed through the built-in LLM gateway. Steps run in agent runtimes such as OpenHands, the Claude Agent SDK, Claude Code, Codex CLI or Gemini CLI. You can mix vendors, for example one model writes the change and another reviews it.
Will it merge code to production without anyone looking?
Only if you allow it. Every project has an autonomy level from assisted (a person at every gate) to dark (no person unless a change touches a protected path or matches your approval policy). You can replay last week's gates under a new level before switching.
How is it different from a coding assistant?
A coding assistant helps one developer in one editor. Nox Kit runs the whole line: it takes work from your tracker, splits it, runs agents in sandboxes, verifies in parallel, asks for approvals in Slack or Telegram, releases in stages and writes everything to an audit log. It uses coding agents as workers rather than replacing them.
What does it cost to run?
The software is free. You pay for your own infrastructure and model usage. The LLM gateway meters every call, enforces budgets per task, agent and client, and forecasts the month's spend at the current pace.
What do I need to self-host it?
One machine with Docker is enough to start: PostgreSQL, Redis, Temporal and S3-compatible storage come up with docker compose. The services scale separately when you outgrow a single host.
Start with one repository on assisted.
Watch a week of runs and read the judge scores. Turn the lights down when the numbers say you can.