Who no_human is for#
Engineering teams shipping Jira or Linear tickets
Teams with a backlog of well-specified tickets and an existing git host can hand the sprint to no_human and review the resulting PRs. The tool syncs ticket status and writes back the PR link, so the board reflects reality without manual updates.
Skip if:
Teams whose tickets lack acceptance criteria or whose repos have no test suite will see the tool park frequently with clarifying questions. Ticket quality and test coverage determine how much supervision is still needed.
Developers working inside Claude Code or Cursor
The MCP server lets you file tasks with no_human from inside your existing AI coding session. You describe the task; no_human plans it, codes it, runs the tests, has it reviewed by a second model, and opens the PR without requiring you to leave your active session.
Skip if:
If you prefer to keep the full implementation loop inside the editor and review output inline, a raw Claude Code session or Cursor BugBot may fit better than handing tasks to a separate orchestration layer.
Solo developers who want async sprint execution
The free local tier runs unlimited tasks bounded only by provider spend. A solo developer can queue several tickets, close the lid, and return to a set of reviewed PRs instead of context-switching between tasks. No subscription required for local use.
Skip if:
If your work requires continuous human judgment at each implementation step (research spikes, architecture decisions, novel APIs with no documentation), the tool will park on questions more than it delivers PRs.
The problem it solves#
AI coding tools have shifted the bottleneck from writing code to checking it. When an LLM writes a change, someone still has to verify it ran the tests, followed conventions, did not delete assertions to make tests pass, and did not invent an API that does not exist. That supervision is not delegation. It is a second job layered on top of the first.
The pain compounds when multiple changes run in parallel. Each one needs a human to track its state, answer its questions, and verify its output before it can merge. Teams using raw AI coding assistants often find they spend as much time reviewing AI work as they would writing the code themselves.
How it solves it#
Independent adversarial reviewer
A second model, in a session that never saw the coder's transcript, reviews every change and must refute 'done'. It produces a pass/fail checklist citing file and line for every blocking finding. No numeric self-scores, no optimistic summaries.
Tamper guard on every attempt
Before the review gate runs, the tool counts deleted tests, new skips, and assertions rewritten into tautologies. An unjustified change stops the attempt. The blocker states exactly which file and line triggered it, so you know what the agent tried to hide.
Reproduction gate for bug fixes
Tests offered as evidence for a bug fix must fail at the merge base and pass on the new tree. The gate runs both states, and the event log records the verdict. Out of the box it binds Python bug fixes; repro_gate.mode: required binds every change type.
CI-integrated test execution
Tests run locally by default and optionally through Jenkins or CircleCI. A PR where no test command was found reads NOT RUN on its face rather than leaving the field blank, so reviewers always know whether tests ran and what the result was.
Ticket tracker and git host sync
Jira, Linear, and monday.com tickets import as tasks; status syncs back to the board when write-back is on. GitHub and GitLab issues import by URL, and PRs or MRs open on your own host. Slack and Teams get a notification when a task needs a human.
MCP server for agent-to-agent handoff
A stdio MCP server lets Claude Code, Cursor, or any MCP-compatible client file tasks with no_human and check their status. Two tools only: task_add and task_status. The server talks to localhost on port 8420 and requires no auth.
Strengths and trade-offs#
Strengths
- MIT license, runs entirely on your machineThe local product is MIT licensed and free forever. It runs on SQLite and your existing git host. There is no code upload to a third-party service, no inference billed through no_human, and no new infrastructure to manage. Your model credentials go directly to Claude or OpenAI.
- Parallel task execution without babysittingMultiple tickets run simultaneously. The tool parks with one specific question when it genuinely needs a human answer, then resumes when you reply. Tickets that can proceed do not wait for the stuck one, and the board shows lane state at a glance.
- Honest stop with a structured recordWhen no_human cannot finish, it stops and records why: a specific question when your answer would unblock it, or a structured failure record when it has run out of budget. It never invents a plausible diff and pushes it anyway. The event log states exactly what happened.
Trade-offs
- -Source build requires Python 3.12+, uv, Node, and npmThe source checkout requires Python 3.12 or later, the uv package manager, git, and Node with npm to build the board UI. The board build is not optional if you want the interface; without it, nh start serves the API only. Desktop app packages avoid this dependency chain entirely.
- -Early-stage project: created August 2026The repo launched in August 2026 and has 273 stars and 13 open issues. Development is active (last push September 2026), but it does not have years of production hardening behind it. Teams running critical delivery pipelines should evaluate it against their own risk tolerance.
- -Inference cost is your responsibilityno_human never resells inference. It uses your own Claude or OpenAI Codex credentials, so every token spent on planning, coding, and review comes off your provider bill. High-volume sprint runs on complex tickets accumulate inference cost that grows with task complexity and attempt count.
no_human vs alternatives#
no_human vs CodeRabbit
CodeRabbit is a cloud-based AI code review service that posts findings on pull requests you have already opened. It integrates with GitHub and GitLab, produces per-line comments, and adds team-level context on paid plans.
no_human and CodeRabbit operate at different points in the delivery loop. CodeRabbit reviews a PR you have already written; no_human writes the change, runs an independent adversarial review with a second model, and opens the PR. The review no_human runs is structurally similar to what CodeRabbit does (a model told to find problems), but it happens before the PR reaches your repo rather than after. For teams that want review automation, the decision is whether the intervention should happen before or after human authorship.
CodeRabbit is the better choice when your team writes code and wants automated review commentary on human-authored PRs. no_human is the better choice when you want to automate the implementation itself, not just the review step.
no_human vs Ellipsis
Ellipsis is a commercial AI tool that reviews pull requests and can generate code fixes in response to review comments. It runs as a GitHub App and adds PR summaries, bug detection, and auto-fix capabilities to an existing PR workflow.
no_human differs in scope: Ellipsis waits for a PR to review; no_human starts from a ticket and drives the full cycle through planning, coding, testing, independent review, and PR creation. no_human's tamper guard (which flags deleted tests or tautological assertions before the review gate runs) has no equivalent in Ellipsis, since Ellipsis does not control the change being made.
Ellipsis is the better choice when you want to add automated review and quick fixes to your existing PR workflow without changing how your team writes code. no_human is the better choice when you want a tool that takes ownership of the ticket from backlog entry to reviewed PR.
no_human vs Cursor BugBot
Cursor BugBot is a commercial feature inside the Cursor AI editor that reviews pull requests for bugs. It is editor-native and integrates with Cursor's coding workflow.
no_human runs outside any editor. It takes tasks from Jira, Linear, monday.com, or GitHub Issues, writes the change, tests it, reviews it with a second model, and opens the PR with no editor required. The MCP server bridges the gap: a Cursor session can file a task with no_human and receive status updates, so both tools can coexist on the same team. Teams using Cursor for active coding can offload routine backlog work to no_human while staying in Cursor for exploratory or complex work.
Cursor BugBot is the better choice when your workflow is editor-centric and you want review embedded in Cursor. no_human is the better choice when you want a standalone agent that handles tickets end to end without IDE dependency.
Install and self-host#
The CLI installs via pipx and ships with the local board.
```bash
pipx install no-human
nh init && nh doctor
```What it's built on#
- Languages
- JavaScriptPython
- Frameworks
- FastAPIReact
FAQ#
Is no_human free to use?
Yes. The local product is MIT licensed and free forever with no credit card required. You pay only for inference through your own Claude or OpenAI account; no_human never resells or meters it. A Pro tier (shared team brain) and Max tier (cloud execution) are planned with pricing announced at launch.
How is no_human different from CodeRabbit or Ellipsis?
CodeRabbit and Ellipsis review pull requests you have already written. no_human writes the change, runs your tests, runs an independent adversarial review with a second model, and opens the PR itself. The scope is the full ticket-to-PR loop, not just the review step. The tamper guard and reproduction gate are also absent from both CodeRabbit and Ellipsis.
Does it work with my existing Git host and CI?
Yes. PRs and MRs open on GitHub or GitLab. Jenkins and CircleCI can run your test layers and gate the loop. Jira, Linear, and monday.com tickets sync as tasks with write-back support. Slack and Teams receive a notification when a task needs a human answer.
Can I run no_human on Linux?
Yes. Desktop packages are available for macOS, Windows, and Linux. The CLI installs via uv tool install no-human or pipx install no-human and ships the local board. Source builds require Python 3.12+, uv, git, and Node with npm for the board UI.
What happens when no_human cannot finish a task?
It parks the task in a Needs Answer lane with one specific question if your answer would unblock it. When it has run out of budget without a clear blocker to surface, it records a structured failure. It never pushes a speculative diff. The event log states exactly why it stopped and what it last attempted.
Similar open-source tools#
Ponytail
The lazy senior dev for your AI agent
FckSignups
Open-source tools that work instantly, no signup required
FreeFlow
Free, open source Mac dictation with AI cleanup and voice macros
patent-disclosure-skill
Chinese patent disclosure drafting with AI-powered point mining
guaardvark
Self-hosted AI workstation with agents, video, voice, and RAG.
lumina
Local-first AI agent that learns, remembers, and never phones home