CortexBuild — Customer Use Cases & ROI¶

A shareable briefing for engineering and business leaders evaluating CortexBuild. Forward this to your team, your sponsor, or your CFO.

Figures labelled target or estimate are forward-looking and will vary by codebase, model choice, and configuration. LLM usage is billed directly to your own provider keys (bring-your-own-key).

1. Executive summary¶

CortexBuild is a team of AI agents that lives inside your repository, works through your backlog, and modernises your legacy code — with user-controlled approval gates at every step. It does the two jobs every engineering org knows it needs but can never staff: modernising the legacy app that works but rots, and burning down the backlog of small tickets that pile up while seniors are busy. You bring your own LLM keys, so your code and your spend stay under your control. Generic enterprise best practices — security review, audit trails, an approval matrix — are baked in from day one, so what the agents produce is reviewable, auditable, and safe to merge. The business outcome: shipped work that would otherwise sit in the backlog indefinitely, at a fraction of the cost of consultancies or new hires, without handing over the keys to your codebase.

Why this holds as models change: the model is a commodity; the harness is the moat. CortexBuild is that harness — a rendered control loop (Planner → Critic → Builder → Tester → Security → Optimizer → PR-Reviewer), governance rules rendered to every agent surface, deterministic eval and guardrail gates, and a recurrence-ledger feedback loop. (CortexBuild renders this workflow into your AI tools today; the fully autonomous orchestrator control loop is on the roadmap — P0 ships render + ledger.) Because a model-agnostic provider router runs it all on your own keys, you can adopt the next frontier model without rewriting any of the governance, evals, or feedback that make its output safe to ship. You are buying the harness, not betting on one model.

2. The problem (in business terms)¶

Every software organisation carries two recurring jobs it cannot fund with human engineers:

Unfunded job	What it looks like	Why it never gets done
Legacy modernisation	The 100k–150k-line app that works but rots: outdated frameworks, missing tests, security debt	Seniors are the only ones who can safely touch it, and they are always busy
Backlog burn-down	50 small bugs and chores piling up in Jira / Linear / GitHub	Each is individually small, collectively enormous, and nobody owns clearing them

Today these are handled in one of three unsatisfying ways:

Ignored — the code decays, security debt accrues, and small fixes take weeks to ship. ("I file a bug Monday; it's fixed in three weeks.")
Outsourced — to consultancies at premium rates, who don't know your conventions and leave once the contract ends.
Hired around — junior engineers with slow ramp time and high fully-loaded cost.

The cost of inaction¶

Decay compounds. Untouched legacy gets riskier and more expensive to change every quarter.
Delivery slows. Senior capacity is consumed by toil, so roadmap features slip.
Spend is hard to defend. Consultancy invoices and headcount are large, lumpy, and difficult to tie back to outcomes.

CortexBuild reframes both jobs as governed, incremental, auditable work done by a team of agents inside your repo — measured in PRs you approve, at a cost you can see line-by-line.

3. Who it's for¶

CortexBuild is built for technical and non-technical leaders alike. The same product exposes two language layers via a persona toggle.

Persona — Priya, Product Manager (50-person eng org)¶

Owns the roadmap; does not write code.
Frustrated that small fixes take weeks because seniors are on big modernisation work.
Wants plain-English visibility, not diffs.

"I want to answer 'what's shipping this week' without interrupting engineering."

Persona — Devansh, Staff Engineer multiplexing 4 projects¶

Manages four services across two teams; reads every PR.
Wants to delegate the boring work (dependency upgrades, test backfilling, documentation) to free up time for architecture.
Wants every change to arrive with a plan, evidence, and a rollback note.

"I never get to the technical-debt backlog."

For non-technical leaders specifically¶

CortexBuild is designed so a PM, a director, or a CFO can govern AI engineering work without reading code:

Plain-English roadmaps. Every modernisation issue carries a business-impact summary, estimated effort, and risk level — drag-to-reorder, tag by quarter.
A cost dashboard to defend spend. Real-time spend, per-task breakdown, month-over-month comparison, projection, and CSV export — the numbers you take to finance.
An audit log for compliance. Every action (by a human or an agent) is recorded with actor, target, payload, and timestamp, tamper-evident via a hash chain — ready for SOC 2 evidence requests.

4. Use cases¶

Each use case is drawn from real CortexBuild user stories. Format: Scenario → What CortexBuild does → Outcome.

4.1 Onboard and map a legacy codebase (Surface A · Story A1)¶

Scenario: Devansh connects a 150k-line Django repo flagged "modernise this."
What CortexBuild does: Clones and installs the toolchain (< 5 min), runs a 4-pass analysis (< 30 min) — structural scan, convention inference, git-history pain-point mining, architecture map — and proposes a ranked roadmap of 15–30 issues with a tech-debt heatmap.
Outcome: A starting point you can edit, reorder, or discard instead of a blank page. Approved issues land in your repo as GitHub Issues.

4.2 Confirm inferred conventions before they become rules (Surface A · Story A2)¶

Scenario: CortexBuild detects that all API handlers use @with_error_handling and proposes enforcing it.
What CortexBuild does: Shows 3–5 file:line citations you can click through to GitHub, then offers Enforce / Advisory / Discard. Your decision is remembered and explained in .cortexbuild/rules/inferred/.
Outcome: Rules reflect your codebase, confirmed by a human — not generic assumptions.

4.3 Approve a modernisation roadmap in plain English (Surface A · Story A3)¶

Scenario: Priya is shown a 23-issue roadmap for a Django modernisation.
What CortexBuild does: Presents each issue with a business-impact summary, effort, risk, and blocker chain; suggests sequencing from dependencies; lets her drag-reorder and tag "this quarter / next quarter / later."
Outcome: A non-technical owner prioritises by business impact and emits a governed plan to engineering.

4.4 Review an agent-opened PR in 5 minutes, not 30 (Surface A · Story A5)¶

Scenario: CortexBuild opens "Migrate users module to async views."
What CortexBuild does: Fills a structured PR body — plan, pre-mortem, evidence, rollback notes, and a confidence score — with file:line citations for every claim. A confidence score below threshold opens the PR as draft.
Outcome: Review time drops from ~30 min to ~5 min per PR; the self-audit pre-fills the checks a reviewer would otherwise do by hand.

4.5 Triage and auto-clear a backlog (Surface B · Stories B1, B2)¶

Scenario: Priya connects Linear and selects the "Bugs" project.
What CortexBuild does: Triages every ticket in < 5 min — complexity (S/M/L/XL), confidence (0–1), suggested action — then works S-tickets above the 0.85 confidence floor in parallel, opening PRs as it finishes.
Outcome: The backlog visibly shrinks; humans stay focused on the work only humans can do.

4.6 Plan-then-execute on medium tickets (Surface B · Story B3)¶

Scenario: A medium ticket — "Add filter UI to orders page."
What CortexBuild does: Drafts a plan (API, DB, frontend, test plan, pre-mortem) with a Critic review attached, and waits for approval before any code is written. Edit the plan inline; reject to re-plan with feedback.
Outcome: No wasted cycles building the wrong thing — the plan is approved before code exists.

4.7 The trust ramp — relax autonomy as confidence grows (Cross-cutting · Story X1)¶

Scenario: After two weeks of clean PRs, Devansh trusts the agents more.
What CortexBuild does: Lets him move any action (e.g. "merge to main") from Approve → Notify in the autonomy matrix at any time. Every change is audit-logged; below-recommended choices show a warning and can be reverted.
Outcome: Governance that tightens or loosens on your schedule — start conservative, earn autonomy.

4.8 Out-of-office approval delegation (Cross-cutting · Story X2)¶

Scenario: Priya is OOO and a PR merge needs approval.
What CortexBuild does: Treats the approval queue as project-level, not user-level — anyone with the admin role can decide, and the decision is attributed to the actor in the audit log.
Outcome: Work is never blocked by one person's calendar; accountability is preserved.

4.9 Rollback and learn from a bad merge (Cross-cutting · Story X3)¶

Scenario: A merged agent PR caused a production issue.
What CortexBuild does: One-click Revert this PR, one-click post-mortem. The post-mortem becomes a recurrence-ledger entry, the Critic gate is updated to block that failure class, and you get a digest: "added recurrence guard."
Outcome: The same class of mistake cannot recur — trust is restored, and the system gets smarter with your codebase.

4.10 Cost dashboard to defend spend to finance (Cross-cutting · Stories X4, A7)¶

Scenario: Priya needs to justify AI spend to her CFO.
What CortexBuild does: Shows a real-time cost meter, per-agent / per-provider / per-task breakdown, month-over-month comparison, projection, and CSV export. Alerts at 80% of budget; hard-pauses at 100% and asks before spending more.
Outcome: No surprise bills; spend is explainable and capped.

4.11 SOC 2 audit export (Cross-cutting · Story X5)¶

Scenario: A compliance officer asks, "who approved this production deploy?"
What CortexBuild does: Exports an audit log (JSON + CSV) for any time range — actor (human or agent), action, target, payload, timestamp — tamper-evident via a hash chain across entries, with 7-year retention on the enterprise tier.
Outcome: SOC 2 evidence in minutes, not a database forensics exercise.

4.12 Budget-aware, never-surprised modernisation (Surface A · Story A7)¶

Scenario: A project's monthly LLM budget is exhausted mid-modernisation.
What CortexBuild does: Pauses, shows exactly what was spent on what (per-agent, per-task, per-provider), and asks whether to top up. Agents resume automatically once the limit is raised.
Outcome: A hard financial guardrail — you are never surprised by a bill.

5. How it works¶

The 5-step flow¶

Connect & interview. Connect a repo (or a Linear/Jira/GitHub Issues board). A short chat-style interview captures business goals and risk tolerance.
Analyse. A 4-pass brownfield analysis maps structure, infers conventions, mines git history for pain points, and builds an architecture map.
Plan & approve. CortexBuild synthesises a ranked roadmap (Surface A) or triages tickets (Surface B). You approve, edit, or discard before any code is written.
Execute under gates. Each item runs through the multi-agent wave model and opens a PR you review in your normal GitHub flow.
Learn. Every rejected PR becomes a post-mortem → a recurrence-ledger entry → an enforced rule. Agent confidence rises over time, visible as a graph.

The multi-agent wave model¶

Unlike single-agent tools, CortexBuild runs a team of specialised agents in a disciplined sequence, the way a mature engineering org would:

Planner → Critic → Builder → [ Tester ∥ Security ∥ Optimizer ] → PR Reviewer
            ▲ governance gate          ▲ parallel read-only review     ▲ merge gate

Stage	Role for a business audience
Planner	Writes the implementation plan and breaks work into dependency-ordered tasks
Critic	Adversarially reviews the plan before any code is written — the cheapest place to catch a wrong approach
Builder	The only agent that writes code — one writer, no conflicts
Tester ∥ Security ∥ Optimizer	Three independent reviewers run in parallel on the same change: correctness, security/compliance, and performance/cost
PR Reviewer	Final merge gate: coverage, regression risk, rollback readiness

Why this matters for governance:

Critic-before-code prevents the most expensive failure mode — shipping the wrong thing correctly.
Approval gates (the 20-class matrix) mean nothing irreversible happens without your explicit yes.
Everything is audited — every agent and human action is logged, attributable, and exportable.

6. ROI model¶

This model is deliberately transparent and conservative. Plug in your own numbers; nothing here is hidden.

Assumptions¶

Input	Symbol	Worked-example value
Backlog tickets handled per month	`T`	40
Fully-loaded engineering cost per hour	`R`	$90
Hours per ticket (incl. context-switching)	`H`	3
Share handled autonomously by CortexBuild	`a`	50%
LLM cost per ticket (BYO key — you pay directly)	`c`	$0.40

Formulas¶

Autonomous tickets / month   = T × a
Hours saved / month          = T × a × H
Gross savings / month        = T × a × H × R
LLM spend / month            = T × a × c          (billed to your own keys)
Net savings / month          = Gross savings − LLM spend
Annualised net savings       = Net savings × 12

Worked example (40 tickets/mo · $90/hr · 3 hrs/ticket · 50% autonomous · $0.40/ticket)¶

Line item	Calculation	Result
Autonomous tickets / month	40 × 50%	20 tickets
Hours saved / month	20 × 3	60 hours
Gross savings / month	60 × $90	$5,400
LLM spend / month (BYO key)	20 × $0.40	$8
Net savings / month	$5,400 − $8	$5,392
Annualised net savings	$5,392 × 12	≈ $64,704

The LLM spend is paid by you, directly to your provider, and is negligible relative to the labour it displaces (~0.15% of gross savings in this example).

Sensitivity — net savings per month¶

Varying autonomous share (rows) and ticket volume (columns). Net per autonomous ticket = 3 × $90 − $0.40 = $269.60.

Autonomous share	20 tickets/mo	40 tickets/mo	80 tickets/mo
30%	$1,618	$3,235	$6,470
50%	$2,696	$5,392	$10,784
70%	$3,774	$7,549	$15,098

(Bold cell = the worked example above.)

Modernisation ROI¶

For Surface A, the savings show up as faster, safer review and less rework:

Lever	Effect
Structured PRs (plan + self-audit + evidence + rollback)	Review time ~5 min vs ~30 min per PR — roughly 6× faster
Time to first PR after connecting a repo	≤ 30 minutes (target)
Recurrence of the same class of bug	< 5% per project per month (target) — the ledger turns each mistake into a permanent guard
PRs that pass CI on the first try	≥ 60% (v1), ≥ 80% (v2) (target)

Important caveats¶

These are estimates; actual results vary by codebase, ticket mix, model selection, and how you set the autonomy matrix.
You pay LLM costs directly via your own provider keys (BYO key). CortexBuild does not mark up tokens.
Conservative inputs are recommended for any business case you present internally.

7. AI optimization & best practices¶

CortexBuild is engineered to keep your team on current AI engineering best practices automatically, rather than depending on each developer to keep up.

Practice	How CortexBuild embodies it
Per-action model routing	Each agent runs on the right model tier — `reasoning_heavy` (Planner, Critic, Security, PR Reviewer), `balanced` (Builder, Optimizer), `fast_cheap` (Explore, Tester) — so you spend premium tokens only where reasoning is needed and cheap tokens everywhere else.
Bring-your-own-key (no lock-in)	Claude, Copilot, Codex, Bedrock, Vertex, or Ollama. (Bedrock and Vertex are reachable via an OpenAI-compatible gateway; no native adapter ships today.) Your data stays in your keys and sandbox; your spend stays under your control.
Self-learning recurrence ledger	Every failure becomes a permanent, enforced guard. The system compounds — more projects mean a richer ledger and fewer repeat mistakes.
Rule SSoT (single source of truth)	One governance source renders simultaneously to Copilot, Claude, Cursor, and Codex — so policy is consistent across every tool, with no drift.
Confidence thresholds	Autonomous PRs require a configurable confidence floor (default 0.85); low-confidence work opens as a draft for human eyes.
Adversarial Critic	An independent agent reviews the plan before code is written — a second model challenging the first's blind spots.
Self-audit	Every agent emits a structured self-audit before declaring work complete: requirements covered, gates run, probes passed.

The net effect: as model providers and best practices evolve, CortexBuild's routing, rules, and guardrails carry your team forward — you adopt the latest AI engineering discipline without re-training everyone.

8. Enterprise standards & security¶

Control	What you get
Bring-your-own-key	LLM keys are KMS-encrypted and never leave the control plane; the platform never sees your raw model spend or data egress.
Per-project sandbox	(Planned, Phase 1) Execution will run in an isolated, devcontainer-native sandbox (Daytona-based, self-hostable on your hardware).
Tenant isolation	Strict separation between tenants and projects across every action.
Full audit log	Every human and agent action recorded — actor, action, target, payload, timestamp — tamper-evident via hash chain, exportable as JSON + CSV.
Retention tiers	90 days (free) · 1 year (paid) · 7 years (enterprise).
PII classification	Geo, identity, and biometric fields are tagged, retention-bounded, and permission-gated by default.
RBAC	Role-based access with a single registry as the source of truth for roles and permissions.
Approval matrix	20 action classes × 3 levels (Auto / Notify / Approve); nothing irreversible runs without explicit approval. (Planned control plane, Phase 2; P0 ships the rule SSoT + recurrence ledger foundation.)
Standards alignment	Generic enterprise best practices baked in: OWASP ASVS, NIST SSDF, ISO 27001-aligned, WCAG 2.2 AA, Azure Well-Architected.
Conformance score	A deterministic, anti-gaming 0–100 maturity score across five dimensions, recomputed from primary evidence every run — hand-editing the report has no effect.

The approval matrix at a glance¶

Level	Behaviour	Example actions
Auto	Performed silently; visible in audit log	Read code, create branch, edit files, open PR
Notify	Performed, with a banner; rollback within 5 min	Install dependency, modify CI, merge to staging
Approve	Blocking dialog; agent waits for explicit yes/no	Merge to main, deploy to production, spend money, rotate secrets

You can shift any row toward more control or more autonomy; going below the recommended default requires a confirmation dialog and is audit-logged.

9. Why CortexBuild vs alternatives¶

The market is full of capable single-agent assistants. The empty quadrant is multi-agent + enterprise-grade governance — and that is exactly where CortexBuild sits.

Capability	Single-agent tools (Devin, Sweep, Cursor, Cody…)	CortexBuild
Agent model	Single agent	Multi-agent wave model with adversarial Critic
Governance	"Yolo" mode or none	20-class approval matrix + full audit
Learning	Forgets each session	Recurrence ledger — compounding memory
LLM provider	Often vendor-locked	BYO key (Claude / Copilot / Codex / Bedrock / Vertex / Ollama) — Bedrock/Vertex via OpenAI-compatible gateway; no native adapter
Execution substrate	Often vendor-locked VM	Daytona-based, self-hostable (planned, Phase 1)
Policy consistency	Per-tool prompt templates	Rule SSoT — render once, fan out everywhere
Audience	Single developer	*PMs and* tech leads** via persona toggle

Defensibility (the moats): the Rule SSoT pattern (hard to retrofit), the recurrence ledger (a compounding network effect), the brownfield analyser (real research-engineering), BYO-key from day one, and the fine-grained approval matrix.

10. Pricing & getting started¶

Indicative tiers (final pricing confirmed at contract):

Tier	Price	Best for
Open Core	Free	Individuals and teams self-hosting the engine
Cloud Team	$50 / seat / month + BYO LLM keys	Teams wanting the hosted UI + control plane (each seat manages a team of agents)
Enterprise	Custom	Tenant isolation, 7-year audit retention, SSO, support SLAs

The Cloud Team price matches single-seat assistants like Augment — but each seat manages a team of agents, not one assistant.
You pay LLM tokens directly to your provider; CortexBuild does not mark up usage.

Getting started¶

Connect a repo or ticket board (GitHub / Linear / Jira).
Complete the 15-minute interview (goals + risk tolerance).
Review the roadmap or triage, approve what you want, and watch the first PR land — first PR in ≤ 30 minutes (target).

Next step: start a pilot on one repo and one backlog project. Measure net savings against Section 6 for 30 days, then decide.

11. Appendix¶

Glossary¶

Term	Meaning
Surface A / B	The two product modes: Legacy Modernisation (A) and Backlog Burn-Down (B)
Wave model	The Planner → Critic → Builder → (Tester ∥ Security ∥ Optimizer) → PR Reviewer sequence
Approval matrix	20 action classes × 3 levels (Auto / Notify / Approve) configured per project (planned control plane, Phase 2)
Recurrence ledger	The append-only store of past failures turned into enforced rules
Rule SSoT	Single source of truth for governance rules, rendered to Copilot / Claude / Cursor / Codex
Confidence floor	Minimum confidence (default 0.85) for autonomous PR creation
Conformance score	Deterministic 0–100 maturity score across five evidence-based dimensions
BYO key	Bring-your-own LLM provider key; you control cost and data
Model tier	`reasoning_heavy` / `balanced` / `fast_cheap` routing per agent