Skip to content
Nox Kit
Open source, MIT license

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.

Get it on GitHubRun it locally
Feature delivery pipeline, autonomy level
  1. Triage, runs unattended
  2. Spec, waits for a person
  3. Design, waits for a person
  4. Build, runs unattended
  5. Verify, runs unattended
  6. Review, waits for a person
  7. Quality gate, runs unattended
  8. Approval, waits for a person
  9. Staging, runs unattended
  10. Production, waits for a person

5 of 10 stations wait for a person

A person signs off at every gate. Good for the first week on a new repo.

Person on the gate Agent at work

A factory for software, not another copilot

Nox Kit runs the delivery line around your coding agents. You define how work gets done: pipelines, agents, models, budgets and the points where a person must say yes. The factory does the rest and shows you every step it took.

Each project has an autonomy level. Start assisted, with a person at every gate. As the judge scores and escaped-defect numbers hold up, move to supervised and then to dark, where the line stops only for protected paths. If defects start escaping, the autonomy guard steps the project back on its own.

Self-hosted
One machine with Docker to start.
Bring your models
Any OpenAI- or Anthropic-compatible provider.
Nothing is decorative
Costs, scores and traces come from real calls.

How a ticket becomes a release

The default feature pipeline. Every stage is a step you can reconfigure, reorder or replace.

  1. 01

    Work arrives

    A Jira story with the factory label, a Linear issue, a GitHub issue, a Slack message or a Sentry alert. A triage agent classifies it and picks the pipeline.

  2. 02

    The planner splits it

    Epics become dependent tasks. Each task gets a written spec and a design note before any code is touched.

  3. 03

    Agents build in a sandbox

    The repository is cloned once per run on its own branch. Agents get only the tools, network and secrets their role allows.

  4. 04

    Verification runs in parallel

    Tests, CI, a security scan and visual checks on a preview URL run side by side. Failures loop back to the builder with the reason attached.

  5. 05

    Review and quality gate

    A reviewer agent, ideally on a different model, comments on the diff. An LLM judge scores the change against your rubric. Below the bar, it goes back.

  6. 06

    Staged release

    Staging, end-to-end checks and docs, then production with a version, release notes and a one-click rollback. Your tracker is updated at every step.

People step in where it matters

When a gate's risk is above your auto-approve policy, the factory asks. In the approvals inbox, or right in Slack and Telegram.

  • Approve with context. The request carries the judge scorecard, the reviewer's notes and the diff stats.
  • Reject with a reason. The work loops back with your comment, and the reason becomes a proposed lesson for the agents.
  • Take a step over. Do it by hand, then hand the run back to the line.
  • On-call rotas. A gate past its SLA pages whoever is on call.

Under the hood

Each part runs as its own process and scales on its own. Configuration lives in Postgres, versioned with draft and publish; YAML export and one-way GitOps if you want it in git.

  • APIAdmin API and the action log. Every change is a command with an audit entry.
  • OrchestratorPipelines are versioned DAGs executed by Temporal, so runs survive restarts and retries are built in.
  • Step workersPluggable executors: agent steps, rules, judges, policies and human gates.
  • SandboxesOne isolated container per run. Docker first; Kubernetes, E2B and Firecracker as providers.
  • LLM gatewayOpenAI- and Anthropic-compatible endpoint. Routes models, meters tokens and cost, stops a step at its budget.
  • MCP gatewayRegisters MCP servers, discovers their tools and hands them to agents by allowlist.
  • Webhook intakeSigned inbound events from trackers, chats and monitoring, fanned out over Redis Streams.

Agent runtimes

Picked per agent, overridable per step. Use one vendor to write and another to review.

  • OpenHands
  • Claude Agent SDK
  • Claude Code
  • Codex CLI
  • Gemini CLI
  • Simulated (dry runs)

Stack

Python 3.12, FastAPI, Temporal, PostgreSQL 16, Redis Streams, S3-compatible storage, LiteLLM. The command center is React with TypeScript.

Plugins everywhere

Step executors, task sources, chat adapters, sandbox providers and preview environments register through Python entry points with their own JSON schema.

Guardrails you can actually enforce

Settings in Nox Kit are rules the engine follows, not labels in an admin panel.

Budgets
Per task, per agent, per client and per month. When a budget is spent, new runs stop and the step reports why.
Protected paths
Changes to migrations, auth, infra or anything you list always wait for a person, even in dark mode.
Agent permissions
Shell, network, repository write and secrets are granted per agent. Without network, a sandbox can only reach the gateways.
Kill switch
One control pauses every run in the installation. Resuming picks up where each run 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 is recorded with who, what and when.

Know whether it works

Metrics and quality are computed from runs, so you can make the case for more autonomy with numbers.

  • Throughput and lead time

    Per project, per pipeline and per client, with the lead-time promise you made.

  • DORA

    Deployment frequency, change lead time, change failure rate and time to restore.

  • Cost per task

    Actual spend from the gateway, split by model and agent, with a monthly forecast.

  • Quality

    Judge scores by rubric, first-pass rate, escaped defects and eval suites per model.

  • Hands-off rate

    How much work went through without a person, why the line still stopped, and the biggest lever to pull next.

Not only code

Pipelines have a domain and their own stage names. Start from a template, then draw the links between steps on the canvas.

Engineering

  1. Spec
  2. Design
  3. Build
  4. Verify
  5. Review
  6. Release

Content

  1. Brief
  2. Research
  3. Draft
  4. Fact-check
  5. Edit
  6. Publish

Support

  1. New
  2. Investigate
  3. Answer
  4. Check
  5. Sent

Data

  1. Request
  2. Model
  3. Validate
  4. Review
  5. Ship

Wired into the tools you already run

  • GitHub
  • GitLab
  • Jira
  • Linear
  • Slack
  • Telegram
  • Sentry
  • Argo CD
  • Vault
  • Vercel
  • Netlify
  • Cloudflare
  • OpenRouter
  • Any MCP server

Two-way sync with trackers, outgoing webhooks with delivery logs and redelivery, chat adapters with routing rules and slash commands, and API keys for everything else.

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 single repository.

Terminalbash
# get the code
git clone https://github.com/makeagentic/noxkit
cd noxkit

# infrastructure: postgres, redis, temporal, minio
docker compose -f deploy/compose.yaml up -d

# command center on http://localhost:5173
cd frontend && npm install && npm run dev

Questions

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.

Set the rules. Turn the lights off.

Star Nox Kit on GitHubRead: what is a dark software factory