AI can write your code.It shouldn't rewrite your business.
nBoard checks every code change against the business logic that governs it, before it reaches production.
Advisory by default. Blocking when you decide. Every decision retained.
octusQ3 VAT rate
Duplicate invoices
How invoices are rounded
VAT is rounded per line, never on the total.
The rules your business already runs on
Every change your team ships
One breaks a rule. It stops before it ships.
Diego sees the rule, sends v2, and it ships.
- Your rules
- Your changes
- The catch
- The fix
GitHub
GitLab
Claude Code
Cursor
Copilot
Codex
Why nBoard
Business logic shouldn't fall between your tools.
Catch business-logic breaks before production. Keep the audit record automatically.
Prevent business-logic regressions.
Every change to governed paths is checked against the rules that govern it before merge. Advisory by default, blocking when you decide.
An audit record by default.
Every decision, every rule version, every author retained. When an auditor asks who authorized a change to your tax logic, the answer is already written.
Business logic that stays up to date.
When code or a regulation changes, nBoard flags every rule it contradicts and every path still running the old version, and opens the work to fix them.
The right constraints at the moment of work.
Whoever picks up the task, engineer or agent, gets the rules that govern it without searching. nBoard stays synchronized with what your team is actually changing.
The walkthrough
Watch it happen on one real change.
A developer changes invoice rounding. CI passes 214 tests. nBoard holds the change: it contradicts FIN-023, the rule a regulator wrote, and routes it to the person who owns that decision.
Integrations
Connect the systems your business rules actually govern.
Know where a rule comes from, where it lives in code, and whether it still holds in production.
Rules
Where the rule originates
Changes
Where the rule gets implemented
Runtime
Where the code actually runs
Business state
Whether the outcome still matches the rule
Why now
Business logic changes faster than your controls can keep up.
nBoard is change control for your company's business logic. Three things happened at once, and all three point the same way.
01
Whoever writes the code no longer has tenure.
Agents produce a large share of new code. An engineer three years in roughly remembers why things are the way they are. An agent remembers nothing, and works at a pace no human review keeps up with.
02
The controls did not scale with it.
A code change is still the same event: a pull request, an approval, a merge. The volume multiplied and human review did not. Nobody can honestly claim they reviewed what they approved.
03
The auditor is already asking.
Internal control frameworks have caught up with generative AI, and the ask got specific: traceability at the repository level, not a policy in a PDF. An automated control can be accepted as effective without repeating last year's testing, provided the control logic did not change. Proving that sentence is exactly what nBoard does.
We don't sell productivity. We sell the change control that AI velocity broke.
Where it fits
Every tool solves one part. nBoard closes the loop.
Docs hold the rule. CI checks the code. Observability watches production. nBoard connects the rule, the change and the record of what was decided.
nBoard
Closes the loopOne system for the rule, the change, the decision and the evidence.
What teams use today
Each tool solves its own layer well. None governs the business rule across the whole change.
One cycle, one record.
FAQ
What engineering leaders ask before joining the pilot.
How is this different from Cursor, Copilot, or Claude Code?
Those tools are smart about code in general. They know nothing about the rules your company is held to. They will happily write a tax calculation that compiles, passes review, and violates a regulation nobody wrote down. nBoard holds that logic as a system of record: the agents read the governing rule before they write, and every change to a governed path is checked against it before merge. No plugins: Cursor, Claude Code, and Codex pick it up out of the box.
We already use Linear or Jira. Why nBoard?
Linear knows what you're working on. It doesn't know which rules that work is subject to, and it can't notice when a merged PR just contradicted one. nBoard governs the logic: it checks the change against the rules for the paths it touches, flags every rule the change contradicts, and opens the work to fix it. Keep tracking work where you track it. nBoard is the layer that says whether what you shipped still complies.
Does nBoard block our merges? What exactly does enforcement mean?
Enforcement means a check on the pull request, not an agent with commit rights. nBoard reports whether the change clears the rules governing the paths it touches, advisory by default. You choose which paths are governed and which of them block; most teams start advisory on everything and promote a rule to blocking once they trust it. On the code itself nBoard stays read-only by design: it checks, flags drift, opens the work with the evidence attached, and routes it to the right owner. It never writes or merges for you. On the roadmap, signals like logs and failed deploys arrive on the same board as tasks with the diagnosis and evidence chain already attached, and for small, well-understood fixes an agent leaves the change ready to merge: branch, diff, passing tests. Nothing ships without going through gates you own: your CI, your review rules. What an agent may touch is an explicit scope you set, never a model's judgment.
How is this different from a Notion wiki or AGENTS.md files?
Wikis are written for humans and go stale the moment the code moves on. AGENTS.md is per-tool, the same context ends up copied across four config files that fall out of sync. nBoard keeps one source in the repo, authored by the people who actually know the rules and read by every agent, so the context lives in one place instead of four. And when the code moves on, nBoard flags the stale page and opens a task. A wiki can't notice it's wrong.
Does our source code or business logic ever leave our environment?
No. Octus runs locally as a CLI on the engineer's machine and operates on the repo they've already cloned. We process metadata and structural context, never source files and we never train on customer code. For regulated buyers we provide a security brief covering data flow, retention, and SOC 2 roadmap on request.
What's the ROI for an engineering leader?
Two things: your senior engineers stop being the human “ask-me” bottleneck, the knowledge that lived in their heads is on the page for the whole team and its agents and you get fewer bad AI merges from agents guessing at rules they couldn't see. For a ~50-engineer team, recovering a slice of senior-engineer interruption time and cutting rework pays for itself fast.
What happens to our knowledge when a senior engineer leaves?
The reasoning that used to live in their head lives next to the code instead. When they leave, the next person and every AI agent, inherits the why behind each decision, not just the code that resulted from it.
Do I have to maintain this by hand, won't it rot like every other doc?
You author the context that matters, and it lives right next to the code it explains, so it travels with the file instead of sitting in a separate wiki nobody opens. That means it's maintained as part of normal work, you update the note when you change the code, the way you'd update a comment and not as a separate documentation chore.
Which agents and stacks does it work with?
Cursor, Claude Code, and Codex read it out of the box, no plugins or custom config. GitHub-hosted repos in TypeScript, Python, Go, and Node are first-class today, and we're expanding to more stacks and hosts through the pilot cohort.
What does getting started look like?
A short pilot on one repo. We pick the governed paths that matter, usually the ones under regulatory or revenue pressure, capture the rules with the people who actually know them, and turn the check on in advisory mode. At the end you get a measurable result: what it caught, and the audit record it produced along the way. No six-month rollout, one repo to prove it.
When can we use it and what does it cost?
Pilot cohort is open now and we're onboarding teams weekly. Pricing during pilot is per-seat with the first month free for design partners who let us publish a case study. Public GA pricing lands alongside broader self-serve availability later this year, waitlist teams get locked-in pilot pricing for their first contract year.