One platform for every stage of software delivery
Four products, one for each stage. They share a workspace, a single connection to your stack and one bill. Two are running today. We haven't built the other two yet, and we won't pretend otherwise.
Reads from the tools you already use
Two products, live today.
Scrum listens to the meeting, then reads your repository to work out who should actually own the fix. Graph takes that same codebase and shows you what your system is doing right now.
See what's shippedTwo more, already in the plan.
One workspace behind all four.
Sprint syncMicrosoft Teams · 32 min“Checkout 500s on payment retries. Stella, can you own the fix? Target Friday.”
PAY-142To DoFix 500 error on checkout payment retries
acme/checkout-platform7 services · 8 dependenciesNext on the platform
- ScrumAvailable nowMeetings in, tasks out.
- GraphEarly accessYour system, live on one map.
- DevOpsComing soonA second pair of hands on the pipeline.
- FinOpsComing soonCloud spend that explains itself.
Two products, one shared workspace.
One listens to the meeting and turns it into tracked work. The other watches the codebase and shows you what your system is doing right now. Both are running today.
Meetings in, tasks out.
Scrum sits in your Teams, Meet or Zoom calls and catches every action item with its owner, deadline and priority, then files it into Jira, Linear, GitHub or Azure Boards. The owner isn't picked from the meeting alone. Scrum reads the repository too, so it knows who has shipped this kind of code before and how cleanly. Pick a stack below and watch it run.
Sprint sync · transcriptCaptured from Microsoft TeamsGarlavatch found 1 action item
PAY-142To DoFix 500 error on checkout payment retries
- Assignee
- SDStella D.
- Due
- Fri, this week
- Sprint
- Sprint 24
- Priority
- High
Created in Jira & assigned automatically
- 01
Understands the room
Reads the whole transcript in context, so a commitment made in passing still lands as a task.
- 02
Reads the code, not just the board
Connect GitHub or Azure Repos and it learns who writes what, how often and how cleanly — so the owner it picks has actually done this before.
- 03
Ready before you leave
The ticket exists by the time the call ends — no post-meeting triage, no lost decisions.
acme/checkout-platform
7 services · 8 dependencies · 1.2k req/min
- Throughput
- 310/min
- p95 latency
- 1.4 s
- Errors
- 12.4%
500 on POST /payments/retry
Introduced 3 days ago in #482 — the retry path now calls Stripe without an idempotency key, so the second attempt is rejected.
Reaches Orders API and the checkout screen.
Your system, live on one map.
Point Graph at a GitHub or Azure Repos repository and it draws what is actually there: services, dependencies, data stores. Then it keeps that picture live. Open it on an ordinary Tuesday to see what is being called, what is slow, what just shipped. Breakages land on the same map. Click any node.
Scope today is your code and the services in it. Servers and infrastructure join the same map next.
- 01
Live, not a snapshot
Traffic, latency and deploys land on the map as they happen — it answers “what is going on right now?”, not “what did we draw last quarter?”.
- 02
Derived, never declared
The map comes out of the code itself — no annotations, no diagram to keep up to date.
- 03
Failures get an address
When something breaks it appears on the node that caused it, with the blast radius drawn around it.
Two more stages, already in the plan.
Neither is built. So neither is for sale, and neither gets a card that looks like the ones above. Here is what each will do when it opens.
DevOps
Not built yetA second pair of hands on the pipeline.
Watches builds, deploys and infrastructure changes, explains why a pipeline went red, and turns the fix into a reviewable change instead of an afternoon of log archaeology.
- 01Failed builds explained in a sentence, not a stack trace
- 02Infrastructure drift caught before it reaches production
- 03Runbooks that stay in step with the repo
FinOps
Not built yetCloud spend that explains itself.
Ties every line of the cloud bill back to the team, service and change that caused it — so the question stops being “why is this up 40%?” and starts being “which one do we fix first?”.
- 01Spend attributed to services, teams and deploys
- 02Anomalies flagged the week they happen, not at invoice time
- 03Savings ranked by effort, not just by dollar amount
03Why one platform
Separate tools. Shared brain.
Buy any one of them on its own. They work. They just get sharper in each other's company: Scrum reads the meeting and the commit history, Graph watches what the system is actually doing. Put the two together and the ticket routes itself.
Scrum knows
Stella has the lightest load this sprint, and 34 of her last 40 commits are in payments/.
Graph knows
The failure starts at payments/retry — one hop from the code she just changed.
Fix 500 error on checkout payment retries
Connect your stack once
Teams, Meet, Zoom, GitHub, Azure DevOps, Jira, Linear — authorise them a single time and every product reads from the same connection.
One workspace, one set of roles
Owners, admins and members carry across all four. No second directory to keep in sync, no fourth invoice to reconcile.
Honest by design
Never a placeholder, never an invented number. It's also why two of these four still say “coming soon” instead of “shipped”.
Pay for the products you actually switch on.
There's no bundle to grow into. The workspace is free while we're in early access. After that, each product is metered on the thing it actually consumes, so switching one on changes your bill by exactly that one.
The workspace
Connect your stack, invite your team, set up roles. You only start paying when you switch a product on.
- Every integration — Teams, Meet, Zoom, GitHub, Azure DevOps, Jira, Linear
- Unlimited workspaces, roles and invites
- The shared context products lend each other
- Review and edit anything before it's final
Then add what you need
Metered on- ScrumAvailable nowper meeting processed
Uploaded or imported, a meeting is a meeting. Members are not counted.
- GraphEarly accessper repository kept in sync
Analysis is continuous, so you pay for the repo — never per scan or per commit.
- DevOpsComing soonpriced when it ships
Announced, not built. Nothing to pay for and nothing to sign up to yet.
- FinOpsComing soonpriced when it ships
Announced, not built. Nothing to pay for and nothing to sign up to yet.
Early access is invite-only, so the rate is set with you rather than off a page. Tell us your stack and we'll come back with a number.
Need SSO/SAML, custom data retention or an SLA? That's a conversation, not a tier — ask us and we'll put it in writing.
Questions, answered.
A suite of AI products for software delivery, one per stage. Scrum turns meetings into assigned tasks. Graph turns your repository into a live architecture map that tells you where a failure came from. DevOps and FinOps cover the pipeline and the cloud bill, and are still being built.
No. Every product stands on its own and you can start with one. They share a workspace, a set of roles and one connection to your stack, so adding the next one is a toggle rather than another onboarding.
It connects to Microsoft Teams, Google Meet and Zoom and imports the transcript automatically. You can also upload a recording or transcript by hand.
In your tracker. Scrum creates and assigns work items in Jira, Linear, GitHub Issues and Azure Boards — Azure DevOps is connected for both boards and repositories.
Read access to the repository, on GitHub or Azure Repos. Graph derives the map from what is actually in the code — services, calls between them, data stores, infrastructure definitions — so there is nothing to annotate and nothing to keep up to date by hand.
It's live. The shape comes from the code, but what you see on it is what is happening now: which services are being called, how fast they're responding, what just deployed, where load is going. Open it on an ordinary day and it tells you what your system is doing — you don't need an incident to have a reason to look.
They're one of the things the live map shows, not the whole point of it. When something breaks, it appears on the node that caused it, with the dependent services highlighted around it and the recent change on that path called out — the service, the blast radius and the likely commit, in the same picture you were already looking at.
Not yet. Today the map is drawn from your code and the services in it. Servers and infrastructure join the same map next — we'd rather say that plainly than imply coverage we don't have.
It reads the meeting and it reads the code. On top of the transcript, who's mentioned, current workload and the deadline, Scrum connects to GitHub or Azure Repos and looks at how each person actually works: what they commit, which parts of the codebase they touch, how their changes hold up in review. So the owner it picks is the one who has done this kind of work before — not the one who happened to speak last.
We're not putting a date on either yet, and we won't list them as shipped before they are. Ask to be notified and you'll hear from us the week they open up.
Your data is only ever yours — we never fabricate or mix in placeholder content, in any product. Enterprise plans add SSO, custom retention and an SLA.
Ready to make your delivery work for you?
Scrum if the decisions from your meetings keep evaporating. Graph if nobody can say out loud how the system fits together. Same workspace, same login, one bill.
Early access is invite-only. Tell us your stack and we'll come back to you.