Inspiration

Every team lead knows the pattern: "Can you build the refund API before our release?" is asked in a hallway, half-agreed in Slack, and nobody checks whether the provider team actually has room. The provider's own priorities, red lines and capacity never enter the conversation, so the dependency slips and both sides blame each other.

We wanted to give that conversation what Codegeist asks for: context. Real sprint capacity from Jira, written team rules from Confluence, and a neutral broker that shows consequences for both teams. Then a binding, visible contract that is monitored instead of forgotten.

What it does

  • Team charters in Confluence. Each team writes a charter page (priorities, red lines, shiftable work, maximum external share, response time, approvers). A Confluence byline item checks whether a page is a valid Accord charter.
  • Request from a Jira issue. From the Accord issue panel (or a Rovo agent) a team asks another team for work, with size (S/M/L), needed-by date and cost of delay. Accord can also suggest a request when someone links two issues of different Accord teams with "is blocked by".
  • Deterministic planner. Capacity comes from the last 6 sprints (realistic = median, pessimistic = second lowest). Options: on time, on time with shifting (cheapest shiftable work first, red lines never touched), partial, later, reject. At most four options, the first is recommended. Every number comes from the data; the LLM never invents one.
  • Two-round negotiation through an async queue, producing a deal sheet with a recommendation and alternatives.
  • Dual approval, then contract. Both team leads approve the same option in the Accord UI. Only then does Accord create the deliverable issue in the provider's sprint, link it with "Blocks", move shifted work and comment. No agent, action or MCP tool can approve.
  • Daily monitor and automatic renegotiation. A scheduled trigger projects every contract at pessimistic throughput. When a contract turns At risk, Accord opens a renegotiation and a deal sheet appears in the Inbox.
  • Rovo agents. Accord Team Delegate represents one team using only its charter and planner numbers. Accord Broker presents the deal sheet neutrally. Both are bound to the planner's output.
  • MCP tools for Rovo Studio custom agents and external MCP clients, running as the invoking user.
  • Audit trail and network map. Every decision, Jira change, monitor result and demo mode change is logged; a network map shows who depends on whom.
  • Per-viewer masking. Users without browse permission on a team's project see the team as "restricted" with aggregate capacity only.
  • Demo tooling. "Seed demo data" creates two demo teams (Mobile and Payments) with boards, sprints, issues, charters and throughput history. "Clean demo data" removes them and restores shifted issues so the demo can be repeated. An admin-only, audited demo mode lets one person approve for both demo teams.

How we built it

  • Platform: Atlassian Forge, UI Kit (React/TypeScript), Node 24 runtime.
  • Modules: jira:issuePanel, jira:globalPage, confluence:contentBylineItem, two queue consumers (negotiation, monitor), triggers (lifecycle, issue link created), a daily scheduledTrigger, Forge SQL (MySQL), two rovo:agent, seven Rovo action modules, one rovo:mcp with four tools.
  • Data: all state (teams, charters, requests, deal sheets, contracts, audit trail, dependency edges) lives in Forge SQL on Atlassian's platform. No egress permissions and no external services.
  • Planner: a pure TypeScript module with no @forge imports, unit-tested in isolation. The Rovo agents get only planner numbers via actions, and their prompts forbid estimating or rounding.
  • Identity and permissions: identity always comes from the Forge invocation context. UI and agent actions run as the user (asUser), so Jira permissions apply. Background work (monitor, queue consumers) runs as the app (asApp).
  • Quality: 335 unit and integration tests pass (Vitest).
  • Distribution: production version 2.8.0, shared through an installation link ("Sharing with anyone").

Challenges we ran into

  • Planner and monitor disagreed. On fresh seed data a brand-new contract was immediately At risk with only one option, because the planner and the monitor used different queue models. We made the planner use the monitor's projection, so a new contract starts On track, and locked it with tests.
  • UI Kit Modal in the issue panel. The first click on a Modal inside the issue panel did not behave reliably. We replaced it with an inline deal sheet.
  • 404 from mypermissions. For users without browse permission Jira returns 404, which we first treated as an error. It now means "restricted": the team is shown with aggregate numbers only, and project keys are masked per viewer.
  • Agents guessed contract direction. Rovo agents inferred who delivers to whom from wording. Actions now return deterministic direction and directionDisplay fields and the prompts require copying them verbatim.
  • Repeatable demo. Seeding is easy; cleaning is not. "Clean demo data" must also restore issues that Accord shifted between sprints, otherwise the demo cannot be run twice.

Accomplishments that we're proud of

  • A negotiation where no number is generated by a language model: agents explain, the planner decides.
  • Real dual control. Nothing changes in Jira until both leads approve, and no agent or MCP tool can approve.
  • A full loop that keeps going after approval: contract, daily monitor, At-risk detection, renegotiation.
  • Zero egress, with all data in Forge SQL inside Atlassian's platform.
  • A non-trivial, tested system (335 tests) that is installed in production and runs end to end on a free developer site.
  • Rovo-specific features are optional: everything except the agents and MCP works on a site without Rovo.

What we learned

  • Forge UI Kit, queues and scheduled triggers are enough for a real asynchronous workflow if state lives in Forge SQL and handlers are idempotent.
  • With agents, the safest design is to take decisions and arithmetic away from the model and give it only verbatim, display-ready fields.
  • Permission edge cases (404 for "no browse", asUser vs asApp) decide whether an app is safe in a real organisation.
  • Demo data deserves as much design as features: seeding, cleaning and a bounded demo mode make an app testable by judges.

What's next

  • Teamwork Graph (FR-13) is not done yet. Today dependency edges are stored only in a Forge SQL fallback table (dependency_edges). Accord does not write to or read from the Teamwork Graph yet. Next step: publish contracts and dependencies to the Teamwork Graph and read cross-product context (goals, people, decisions) from it for the planner and the network map. We are not claiming the Teamwork Graph bonus.
  • Marketplace listing and a security review.
  • More planner inputs (release dates, multi-team chains) and richer charters.
  • Notifications for approvers in Jira and Confluence.

Built With

  • atlassian-forge
  • confluence
  • forge-queues-(events-api)
  • forge-scheduled-triggers
  • forge-sql
  • forge-ui-kit
  • jira
  • jira-software-(agile-rest)
  • mysql
  • node.js-24
  • react
  • rovo-actions
  • rovo-agents
  • rovo-mcp-(rovo:mcp)
  • typescript
  • vitest
Share this project:

Updates

Submission history