Review what can change the work
Accepted-spec review, plan approval, final acceptance, and risk decisions arrive with the current target and required action.
Governed agents · human judgment
Your Agents. Our Governance.
Connect the AI models you already use. ScrumDo gives them deep context from customer stories and team judgment — so they can help deliver superior outcomes while you stay in control.
Humans keep judgment.
Governed attention
Bring people back for decisions, not every event.
ScrumDo routes approvals, proof gaps, exceptions, and accepted risks back to the exact card and version that need attention. Optional updates can be watched, muted, or sent through configured channels without turning chat into the authority.
Surface proof gaps and stale approval
Failed runs, changed targets, blocking review comments, insufficient proof, and revision limits return to a person instead of disappearing into logs.
Watch what matters and mute the rest
People can watch selected work and tune optional updates. Policy-protected acknowledgments remain visible until an authorized person handles them.
Notifications never authorize agent action.
Slack and Microsoft Teams can deliver a safe summary when configured. Approval, acknowledgment, and the audit record remain in the governed work surface.
Read the governed attention guideAgents participate across all four layers — not in a separate chat you have to context-switch into.
Agents suggest. Humans decide. Nothing becomes official until a person accepts it.
Most tools bolted on AI. ScrumDo is a work system where governed agents were always meant to participate.
One work record for planning, flow, and delivery. Agents surface context, draft proposals, and execute only through that governed card. Humans interpret, decide, and accept what becomes official.
Agent economics & zero markup
Stop paying the per-seat AI tax.
Other tools charge an extra $7–$20 per user every month for a closed chatbot wrapper. ScrumDo charges $0 platform markup—letting your engineers connect the frontier subscriptions (Claude, Cursor, Codex, Grok, Copilot) they already pay for.
| Platform | AI Pricing Model | Per-Seat Surcharge | Annual AI Cost (25 Users) | Model Freedom | Governance & Approvals |
|---|---|---|---|---|---|
| Atlassian Jira (Rovo AI) | Per-seat monthly add-on fee | +$20 / user / mo | $6,000 / year | Closed suite model (Atlassian proprietary) | Basic workspace permissions; no card-spec provenance |
| ClickUp (ClickUp Brain) | Mandatory workspace per-member fee | +$7 / user / mo | $2,100 / year | Closed wrapper bot; cannot bring custom models | Basic chat responses; no token budget limits |
| Notion (Notion AI) | Per-member add-on fee | +$8–$10 / user / mo | $2,400–$3,000 / year | Closed vendor wrapper | Document-only assistant; no card execution |
| ScrumDo Governed BYOARecommended | $0 platform markup (Bring Your Own Agent) | $0 / user / mo | $0 (Direct provider at cost) | Any frontier model: Claude, Cursor, Codex, Grok, Copilot | Strict human approval, token budgets, card context provenance |
Three levels of involvement
How Agents Work in ScrumDo
ScrumDo supports three levels of agent involvement, always keeping human judgment at the center.
Guided AI
You trigger it.
Manually ask your agents for help directly inside cards and boards. They read real work context, customer stories, and team judgment to provide relevant assistance.
Governed Agents
Your workflow triggers it.
Use Flow Rules to automatically involve agents when specific conditions are met. Every draft or action requires human review before execution.
Orchestrated at Scale
You bring your own.
Agents operate across multiple rooms and portfolios with context carried by the app and governance applied at each boundary. Humans retain full oversight of sensemaking and decisions.
Where agents participate
What changes when agents operate inside the workflow.
Organization
the system
Rooms, policies, portfolio economics, and governance span the whole operation.
Boards
views
Delivery, planning, and portfolio surfaces read the same underlying record.
Columns
workflow states
Where work waits, where Flow Rules fire, and where WIP limits keep flow honest.
Cards
commitments
Stories, specs, evidence, and agent proof live on the governed work record.
How it works
ScrumDo acts as the orchestration layer between your agents and your work.
- Agents connect through governed interfaces (API or MCP).
- They receive rich context directly from cards, stories, blockers, and evidence.
- Nothing executes without human approval.
- All agent activity is logged and traceable.
This allows your agents to produce more relevant and useful output because they operate inside real work context instead of isolated prompts.
Governed lifecycle
From card context to proof on the record
Six steps where agents propose, humans accept, and proof returns to the same card, not a side chat.
The card gathers context
Customer stories, team judgment, card fields, blockers, and source-linked evidence stay together.
The agent drafts the spec
An approved agent can propose a spec from the card, interpreted stories, evidence, and repo context.
A human accepts the spec
The accepted spec changes only when a human reviewer accepts, edits, or supersedes the proposal.
The agent proposes a plan
The execution plan is visible before the run, including intended files, checks, and assumptions.
A human approves the run
Execution waits for approval. The reviewer can approve, request changes, or cancel.
QA and PR return
QA verification, safe reports, commits, pull requests, cost, provider, and outcome evidence return to the card.
The spec is the contract
Product intent becomes executable before an agent implements.
The Living Working Spec on the card holds acceptance criteria, business rules, and known failure modes as tests. Those tests become the boundary the implementation agent works inside.
Intent first
The Product Spec becomes tests before anyone implements.
Acceptance criteria, business rules, and known failure modes start as executable examples. Those tests join the Living Working Spec on the card. They become the boundary the implementation agent works inside.
Behavioral contract
End-to-end scenarios are the primary contract.
Treat the application or a subsystem as a black box. A small set of critical scenarios runs on every change. Broader scenarios run less often. Traces, screenshots, logs, API responses, and videos stay with the card. Unit tests isolate critical logic or an edge case that is too expensive to run end to end.
The spec holds
When a test fails, the implementation changes.
The person or agent who derives the tests is different from the agent that implements. A failed test leaves the accepted spec in place. A production defect first asks which requirement was missing. Strengthen the spec, encode the behavior, then fix the code. The same rule covers security, performance, concurrency, resilience, privacy, and resource use.
The development system enforces the workflow.
Product Spec defines intent. Tests encode executable constraints. Agent instructions and CI keep the implementation inside that boundary. A human changes the spec. The agent keeps working until the tests pass.
Humans keep judgment
Agents read meaning. Humans interpret it.
Customer stories, blockers, evidence, and outcomes stay on the card. People interpret them. Agents assist from that context.
Stories on cards
Customer stories stay where humans interpret them
Stories and signifiers stay attached to the card so people ground requirements in lived experience. Agents read that context. They do not flatten meaning or decide what customers need.
Blockers & flow
Blockers and handoffs help humans see what is stuck
Dependencies, WIP pressure, and delivery friction stay visible on the board. Agents can surface patterns from the record, people decide what to unblock, reprioritize, or escalate.
Evidence & specs
Evidence and accepted specs ground human judgment
Source-linked evidence and human-accepted specs travel with the card. Agents draft and check from that material; reviewers approve what becomes official. Agents do not sensemake the tradeoff.
Outcomes on record
Outcomes return to the card for the next decision
Reports, reviews, time, budget, and cost-of-delay context stay tied to the work record. Humans learn and reprioritize from proof on the card. Agents do not rewrite portfolio meaning.
Advanced capabilities
Built for Scale and Trust
Controls for teams running multiple agents across rooms and repositories, with human approval and proof kept on the operating record.
Living Working Specs
The Product Spec on the card holds requirements, architecture, acceptance criteria, and executable tests. Those tests freeze product intent before an agent implements, and they become the boundary the implementation works inside.
Governed Skills & Action Gates
Define exactly which skills and commands agents are permitted to run, with mandatory human sign-off gates before code merges or actions take effect.
Connectors & Tool Proof Trails
Securely link external developer tools with full provenance and verifiable audit trails on every card record.
Action Limits & Token Governance
Control monthly approved action budgets and prevent runaway AI costs with per-member and per-room allocation caps.
Context Provenance
Full visibility into what information agents used when generating suggestions or drafts.
Multi-Agent Workflows
Coordinate specialized agents across rooms and projects under consistent governance.
Connect external tools through approval gates, not open pipes.
…and more
MCP for the tools you already use
Bring governed ScrumDo work into your AI assistant.
Use Codex, Claude Code, Cursor, or another compatible client to read permitted cards and accepted specifications, propose work, and return tasks, pull requests, and proof to the same record.
Why teams choose ScrumDo
Why Teams Use Agents in ScrumDo
Decisions
Better decision quality from grounded context
Agents read stories, blockers, and evidence on the card. They do not sensemake. Humans interpret meaning; agents surface the context that makes judgment faster and more defensible.
Risk
Reduced risk as agents scale
Human approval gates, visible context provenance, and room-scoped permissions mean agents propose and execute inside boundaries, not as unattended automation hiding in side channels.
Control
Human control by design
People accept specs, approve plans, and review proof. Agents assist at every level, but humans decide what becomes official on the work record.
Collaboration
Scalable collaboration without lost oversight
Teams, rooms, and agents share one governed record. More work and more agents do not mean more side chats, context, proof, and accountability scale together.
- Deliver higher-quality outcomes by giving agents access to real customer stories and team judgment.
- Scale agent usage safely without losing control or traceability.
- Preserve anonymity and data boundaries while still benefiting from agent assistance.
- Maintain a single source of truth where human decisions and agent activity live together.
- Reduce risk while increasing speed and consistency across complex work.
Guardrails by design
Nothing becomes official without a person
Approval gates, provenance, and connector proof keep agents inside boundaries your team sets.
Human-owned accepted specs
Freeze the accepted spec and its tests before the agent implements. When a test fails, the implementation changes. A human changes the spec; the agent keeps working inside that contract.
Approval gates
An agent can draft, but execution waits for a human-approved plan. Approval is part of the work record.
Visible context provenance
Reviewers see what context an agent used to draft a spec or plan—readable sources and staleness, not hidden prompt payloads.
Connected tools on the record
When agents use GitHub, chat, trackers, or observability tools, links and proof return to the card—not a separate audit log you have to hunt for.
Governed agents · real context
Ready to equip your agents with real context?
Start using governed agents in ScrumDo today.