Every lab ships an agent. NB is the brain above them all.

Companies directly supervise and audit fleets of AI coding agents working in their own repos. Humans just review PRs.

Request a walkthrough See the product

Above every agent

The agents come and go. Your organization's brain stays.

Every lab ships its own agent.

Anthropic, OpenAI, Google and xAI each ship one, and each works inside its own walls. What it picks up stays in that lab's silo.
None of them carries your brain.

Your rule books, the lessons you paid for, the decisions you made and the history of every run. That is your organization's brain, and no single agent holds it.
NB holds it, and lends it out.

NB keeps that brain and hands it to whichever model and harness does the work, so the next agent starts where the last one left off.

What NB has access to

Connect everything.

Every frontier model, through the harness that runs it, and the tools your team already works in.

Models and harnesses

Claudevia Claude Code
OpenAI modelsvia Codex
Geminivia OpenCode
xAI Grokvia OpenCode
Any LiteLLM modelvia Claude Code on LiteLLM

Code and issues

GitHubpull requests and checks
Linearissues

NB is not tied to one provider or one harness. A new one is a connection, not a migration.

Also connected

Chat

Slack
Discord
Microsoft Teams

Meeting notes

Granola
Fireflies
Wispr Flow
Otter

Calendars

Google Calendar
Microsoft Outlook Calendar
Apple Calendar

Issues

Jira

Everything else

Any MCP server

How you work with NB

One thread, from a goal to a pull request.

You type what you want. NB plans it from your organization's brain, runs it, and comes back with the one thing that needs you.

You

Customers keep asking for their invoice history. Add a CSV export to the billing page.

Here is the plan. I drew it from your organization's brain before writing a line.

Rule bookBilling changes ship behind a feature flag.
Rule bookEvery new endpoint gets a permission test.
LessonLarge exports timed out inside the request on an earlier run, so this one streams.

Export endpoint first, streamed. Then the button, behind the billing flag. Then tests for permissions and for an empty history.

Branch opened from main
Export endpoint written, streaming the rows
Button added behind the billing flag
Permission and empty-history tests added
Checks passed on the branch
Reviewer agent read the diff against the rule book

Pull request ready for your review Add a CSV export of invoice history waiting on you

Open the pull request

Add a CSV export of invoice history

nb/invoice-csv-export into main

billing/export the streamed endpoint
billing/export.test permissions and empty history
billing/BillingPage the button, behind the flag

The merge is yours. NB does not merge its own work.

Show the evidence

Checks passed on the branch
Permission test a member without billing access is refused
Empty history the file holds the header row only
Review the reviewer agent found nothing against the rule book

Every line links back to the run's event trail.

Why this plan?

The flag comes from the rule book: billing changes never go live by default. The streaming comes from a lesson a past run paid for, when a large export timed out.

Nothing in the plan is invented for this task. Each step points back to a rule or a lesson.

Example thread, written to show the flow. Not a customer run.

A clear view of the work

Everything your agents do.
In one place.

01 / See the whole fleet

Runs in flight, decisions waiting, and a standing supervisor. The project view brings the next move into focus.

02 / Follow every run

Start with a goal. Follow the plan, individual tasks, checks, and event trail. Nothing important disappears into a terminal.

03 / Know what needs you

A briefing turns activity into a short list of concrete decisions. Open the evidence, make the call, move on.

See a run unfold

NB project overview. — Actual NB screens, example project data.

Actual NB screens, example project data.

Inside a run

From activity to a decision.

The ledger and event trail for one run, embedded straight from the product as it advances toward a decision.

NB run view with the ledger and event trail.

How it works

Under the thread, five gated steps.

What NB does between your goal and the pull request: one task at a time, supervised end to end, with the evidence carried along.

Fire

A ticket or a written goal lands, from your tracker or typed straight in. NB accepts it as the one thing to build next.

Plan

Turn the goal and your rule books into scoped tasks with clear acceptance criteria.

Work the tasks

Agents implement one bounded piece at a time in isolated workspaces. The ledger keeps the sequence visible.

Gate

Run the checks. Review the diff against the rules. Carry the verification evidence with the change.

Land

A pull request reaches you with its context intact. You review and authorize the merge.

Every task gets a clear head.

The orchestrator remembers, so no worker has to.

One long agent session

Every file it read and every dead end it tried piles up in its context window. When the window fills, the session is compacted: its history is summarized to make room, detail is lost, and the agent carries on from a lossy memory of its own work. That is where long runs drift.

NB: a clear-headed worker for each task

The orchestrator holds the plan and the ledger. Each task goes to a worker that starts with only what that task needs: the goal, your rules, its acceptance criteria and what is already done. It builds one bounded piece, commits, reports and stops. Task forty starts as clear, and meets the same gates, as task one.

Capabilities

Everything a supervised fleet needs, in one instance.

Boring on purpose. Each part does one job, in plain terms, so an operator always knows what happened and who did it.

Command console

A single-screen cockpit over every project and agent, with role-based accounts and a per-user audit trail.

Orchestration engine

Drives work one task at a time, all the way to a pull request: leasing, spawning, verifying, and committing without a human in the loop.

Conversational operator

A plain-language assistant that runs the board with you: a persona named for your organization, not a generic bot.

Rules and conformance gates

Every change is bound to your organization's own rule books, with automated gates at pull-request time.

Docs and specs at scale

Documentation and specification management that keeps the fleet grounded in what you actually intend to ship.

Brandable deployment

Containerized and white-labeled: your name, your operator persona, one environment switch from install to running.

Evidence, not a leap of faith

Built for founders running a fleet.

You should not have to read every terminal to know what is moving. NB keeps the work visible and the consequential decisions yours.

6example runs to explore

3example projects in the demo

1place to follow the evidence

Demo fixture counts, not customer or production results. Explore the real screens above.

Deployment model

Your instance. Your network. Your code.

A single-tenant, white-labeled instance in your cloud. NB runs where you run everything else, and your repositories stay under your control.

Tenancy: Single-tenant instance, one per customer.On your infrastructure, or ours. No shared control plane.
Access: Private-network only.No public application surface to expose or defend.
Providers: Any provider, any harness.The models and tools under what NB has access to.
Your code: Your repositories never leave your control.Agents work in your own repos and open pull requests there.

Point a fleet at your repos. Stay on the PR.

Tell us about your stack and your rule books. We will walk you through a single-tenant instance in your cloud.

[email protected]