# no_human

> An AI software-delivery loop that runs on your own machine. You give it a
> ticket; it plans, writes the code, runs your tests, has an independent
> reviewer try to refute "done", and opens a pull request. It never merges —
> merging is always a human action.

Free and open source (MIT). The program described here is the one you install
and run yourself: it executes on your machine, against your own model
credential, with no server of ours in the request path and no account needed.
(getnohuman.com also has a sign-in page and waitlists for paid tiers that would
run the work on our infrastructure instead; none of that is required to use
what this file describes, and none of it is what an agent should call.)

## When to use this

Reach for no_human when a developer wants a change carried from a ticket to a
reviewable pull request without watching it happen:

- A bug fix with a reproduction: for a Python bug fix it writes a test that
  fails on the merge base and passes on the new tree. Out of the box that gate
  is advisory and only binds a bugfix whose edits went through the edit tools;
  set `repro_gate.mode: required` to bind every kind and every change.
- A scoped feature or refactor in an existing repository, where the acceptance
  criteria can be written down.
- Work that must arrive as a PR a human can audit: by default every PR carries
  the
  reviewer's pass/fail checklist with file-and-line evidence, the test output,
  and what could not be verified.
- Repositories where every landing must be a human command, and where pushes to
  protected branches are refused by the tooling rather than left to policy — on
  the default backend before the push runs; see the layers below.

Do not reach for it when: you want a chat-style pair programmer for a single
edit (use an interactive assistant); you need work merged automatically (it
refuses by design); or you cannot run anything locally — the local product is
the only thing available today, and the hosted tiers are waitlist-only.

## How an agent should call it

no_human is a local program, not a web API. Two supported entry points:

- **MCP server** — `uvx no-human mcp-serve`, or the Claude Code plugin in the
  repository. Two tools: `task_add(title, description, repo_path)` and
  `task_status(...)`. This is the agent-facing interface.
- **CLI** — `uv tool install no-human` then `nh task add …`, `nh status`,
  `nh approve <id>`. 45 top-level commands; `nh --help` lists them.

Both entry points can talk to a local server on `127.0.0.1:8420`, started by
`nh start`. The MCP bridge (`nh mcp-serve`) and the conversational shell (`nh`
with no arguments, or `nh shell`) talk to it and never open the database
themselves. Nine other subcommands may check whether a server is running
(`nh task add`, `nh task pause`, `nh task cancel`, `nh status`, `nh watch`,
`nh reply`, `nh auth status`, `nh auth use` and `nh auth set-token`);
`nh watch`, for one, runs the task in this process when that check finds
none. The other 69 subcommands (80 leaf commands in all, grouped under 45
top-level names) never talk to that server. That server's HTTP API is
documented by the OpenAPI spec below; it is bound to loopback by default
(`nh start --host` changes that) and carries no authentication of its own,
aside from a loopback-origin check on a handful of routes that write to disk.
The [privacy policy](https://getnohuman.com/privacy) describes what leaves
the machine.

## Developer resources

- [Documentation](https://getnohuman.com/docs): install, first task, configuration.
- [OpenAPI specification](https://getnohuman.com/openapi.json) — a published
  copy of the 0.1.4 spec of the LOCAL server's API (the live one is served by
  your own installation at `http://127.0.0.1:8420/openapi.json` once
  `nh start` is running; there is no hosted endpoint): 71 paths and
  77 operations, each with an operationId and a summary. Errors are structured
  JSON — `{"detail": ...}` (a string, or a list of validation errors on 422)
  with conventional status codes (404 unknown
  task, 409 illegal transition, 422 validation). Response schemas are
  uneven: a minority name a concrete type, most declare only a free-form
  object, and a few declare nothing — so read it for the surface, not as a
  contract you can code-generate against.
- [Source and issues](https://github.com/no-human-ai/no_human): MIT-licensed.
- [PyPI package `no-human`](https://pypi.org/project/no-human/): the `nh` CLI
  and the MCP bridge.
- [Cost model](https://getnohuman.com/cost): what a task costs and why.
- [Privacy](https://getnohuman.com/privacy) · [Terms](https://getnohuman.com/terms)

## What it will not do

- It never merges a pull request. Landing one is a separate human command
  (`nh approve <id>`). Agent sessions are denied the obvious spellings of that
  command at the tool call; that guard raises the cost and is not a closed
  door, and the project documents its known gaps rather than listing
  exceptions as if it were one.
- It never pushes to `main`, `master` or `release/*`, and that rule has real
  enforcement behind it — but the enforcement differs by backend, so read it as
  layers rather than as an absolute. On the default Claude backend the push is
  refused before it runs, and a second layer, a git `pre-push` hook that reads
  the ref git itself resolved rather than the text of the command, is installed
  into each isolated task worktree and fails closed if it cannot read its own
  rules. On the Codex backend there is no pre-execution veto available, so the
  same rules are evaluated on an already-executed call — detection, not
  prevention — and a hook-disarming push flag is refused only by the layer that
  backend does not have. Running without worktree isolation (not the default)
  removes the hook layer as well.
- It does not send your code to a service of ours: it runs on your machine
  against your own model credential.
- It does not report a task done without evidence — when it cannot finish
  honestly it stops and says what it is blocked on.