Cortex

Agent runs your team can govern.

A Linear issue becomes a plan. A sandboxed coding agent implements it. A person approves at every gate, in Slack or right here, and the pull request merges with the whole decision on record.

Sign inSee how a run goes

Works withGitHubSlackLinear

The feature run beside this is waiting for you. Approve the plan and watch it go.

Issue PAY-123 · Refund endpoint · feature templateNeeds a decision
  1. owner
  2. plan
  3. planGate
  4. implement
  5. pr
  6. ci
  7. review
  8. reviewGate
  9. merge
  10. done

Approve the plan?

Assigned to ana · answer within 4h · opened · also posted in Slack

Refund endpoint for closed ordersS

Add POST /refunds behind the payments router, validate amount against the captured total, write a ledger entry, and notify the customer.

  1. Route and validation — new handler, amount and reason checkssrc/payments/refund.ts
  2. Ledger entry — append a refund row in the same transactionsrc/ledger/writes.ts
  3. Tests — partial refund, full refund, closed ordertests/refund.test.ts

Tests: pnpm test; contract test against the sandbox gateway

Risks: double refunds on retry: use the order id as the idempotency key

Raw plan

A comment on an approval is kept as a note; on a rejection it says why.

How a run goes

The path from issue to merge is an explicit graph. Agents do the work; the points where a person decides are nodes with an owner, a deadline and an escalation.

  1. An issue moves to Ready. Linear tells Cortex; the team's owner is picked by capacity.
  2. The planner reads the repo and your memory and writes a plan: steps, files, tests, risks.
  3. The owner approves the plan, edits it, or sends it back, in Slack or here.
  4. A sandboxed agent implements it, opens the pull request on GitHub and waits for CI. It never holds a credential; every request leaves through a gateway that allows only the run's own repository.
  5. A reviewer reads the AI review and decides. Changes requested go back round the loop, at most twice.
  6. Merge, and the issue moves to Done. The log keeps who decided what, and what it cost.
Slack#payments
Cortex09:41
PAY-123 · Refund endpoint · plan ready for @ana · answer within 4h
Refund endpoint for closed orders · size S
3 steps · 2 tests · 1 risk: double refunds on retry, keyed by order id
Ana09:44
approved · “remember: refunds are keyed by order id”
Cortex09:44
Implementing in a sandbox · remembered for payments

Agent progress

implement · running for 2 min 11 s
implementclone: acme/payments at main
implementread: src/payments/refund.ts, src/payments/router.ts
implementmemory: 3 notes · refunds keyed by order id
implementedit: add POST /refunds with amount and reason validation
implementedit: tests/refund.test.ts · partial, full, closed order
implementtest: pnpm test · 48 passed
implementpush: cortex/pay-123-refund-endpoint
implement: opening the pull request

What your team keeps

Decisions, on record

Every gate names its approver, its deadline and its answer. The run's event log is the audit trail, and it is the same log the live page is drawn from.

Memory that compounds

A comment on a gate, a /cortex remember in a channel, a note typed here: scoped, confirmed by a lead, in front of the next run's agents. Never written into your repository as the source of truth.

Cost you can see before the invoice

Model calls and sandbox minutes are metered as the run goes, against a monthly budget and a per-run cap. Over the limit, runs stop; the number is on the run page while it happens.

Budgets are a meter, not a surprise. This is November for a team two runs in.

Usage

November 2026
Model spend$7.277% of the limit
Sandbox time32 min5% of the limit
Runs with spend
2
PAY-123 · Refund endpoint
$4.86 · 23 min
PAY-119 · Retry webhooks
$2.41 · 9 min
Per run, at most
$10.00

Start with one team.

Sign in, create the organisation, connect GitHub, Slack and Linear, map a team to a channel and a repository. The first run is a review of a pull request a person already opened.

New organisation

You become its admin. Connect GitHub, Slack and Linear next.

Who is it for
Create Acme Payments

Sign in first; the organisation is created on the next screen. One team can start today.