Program management software for Jira and Asana

The Program Manager is program management software that maps cross-project dependencies across Jira and Asana, watches every milestone for risk, and keeps blockers, decisions and approvals in one graph. Ask about it in Claude or ChatGPT, and approve every change before it happens.

Team from $59 per workspace per month. A card is required at checkout. See pricing

Portfolio · DependenciesExample

Milestone risk

Q4 Launch+9d

Payments GA+6d

Launch siteon track

Critical blocker

Auth service holds 2 milestones

Domain MCP tools

Live connectors: Jira, Asana, Slack

Blocker workflow states

Product

One graph for every program, milestone and blocker.

Cross-program visibility without replacing the tools your teams already use. The Features page shows what each part stores and does.

Cross-program dependency graph

Hard, soft and informational links between work items across Jira and Asana, verified or flagged as suggested.

get_dependency_graph

Milestone risk monitoring

Baseline versus forecast for every milestone, with a deterministic impact preview when an upstream item slips.

analyze_milestone_impact

Blockers and escalations

Eight-state blocker workflow with owners, due dates and the milestones each blocker holds.

list_critical_blockers

Decision log

Options, rationale, approver and follow-up deadline for each decision, linked to the milestones it affects.

decisions · approvals

Approvals for every agent action

Agents propose links and escalations. Nothing is written until a person approves the exact payload.

propose_* → execute_approved_action

Weekly program review

Progress, milestone movement, blockers, decisions and asks, assembled from live data for each program.

get_weekly_program_brief

MCP clients

Ask in plain language. Approve what changes.

Add The Program Manager as an MCP server in Claude, ChatGPT, Claude Code or Cursor. Agents read the dependency graph, milestones, blockers and decisions, and every proposed write lands in your approval queue.

1
Add the MCP server
Create a workspace token in Settings, then add the server URL and the token as an Authorization header in your MCP client.
2
Ask about the portfolio
“Which dependencies threaten the Q4 launch?” The agent answers from live program data with evidence.
3
Approve, then execute
Proposed links and escalations wait for approval with an expiry. Approved actions are executed and recorded in the audit log.

Setup steps and the tool list are on the MCP page.

C ClaudeG ChatGPT>_ Claude Code

Claude · The Program Manager connectorExample

Which dependencies threaten the Q4 launch?

get_dependency_graphprogram: “Q4 Launch”

analyze_milestone_impactdelay_days: 6

Two upstream items sit on the critical path. Auth service is blocked on a vendor review and pushes Payments GA, which moves the launch by about 9 days.

Proposed: escalate Auth service blocker to Platform lead in Slack

Needs approval

Review in Approvals before anything is sent

How it works

From scattered trackers to a decision in four steps.

01
Map your launch
Connect Jira and Asana with an API token and pick the projects that make up each program.
02
Detect the slip
Dependencies and milestone forecasts update on every sync. Stale sources are labeled, never shown as green.
03
Escalate with precision
See which blocker holds which milestone, who owns it, and draft the escalation to Slack.
04
Review and decide
Run the weekly review, log decisions with rationale and approve agent proposals.

Integrations

Connect Jira, Asana and Slack.

Each connector uses an API token that you create yourself. The token is stored server side and never reaches the browser.

Jira Cloud

Supported

Issues, epics, status transitions and cross-project links

read:jira-work

Asana

Supported

Projects, tasks, sections and task dependencies

default

Slack

Supported

Program updates, escalation alerts and status broadcasts

chat:write channels:read

Security

Tenant isolation, server-side credentials, audit everything.

Row-level security on every table

Organization-scoped isolation enforced in the database. The service role never reaches the browser.

Server-side credential storage

Provider tokens are sent once and stored server side. Never in the browser, never in generic logs.

Every external write is approved

Propose, approve, execute, verify, record. Single-use approvals expire and carry a payload hash.

Provider data is untrusted

Task descriptions and comments from third parties never execute as instructions. No secrets go to tools.

Audit trail

Consequential actions are logged with actor, resource and timestamp.

Fail closed

Stale sources show timestamps and unverified risk. Never a false green status.

MCP tool contract

Ten domain-level tools, not dozens of raw API wrappers.

Every tool returns explicit action statuses, evidence and deep links back to the dashboard. The full list is on the MCP page.

list_programs, get_program_status, get_dependency_graph
analyze_milestone_impact: deterministic preview, no remote mutation
list_critical_blockers, get_weekly_program_brief
propose_dependency_link, propose_escalation: gated writes
execute_approved_action: verifies the approval, then performs it
get_program_changes: normalized change events with source timestamps

tools/list

{
  "tools": [
    {
      "name": "analyze_milestone_impact",
      "description": "Deterministic impact preview
        for a milestone delay",
      "inputSchema": {
        "type": "object",
        "properties": {
          "program_id":   { "type": "string" },
          "milestone_id": { "type": "string" },
          "delay_days":   { "type": "number" }
        },
        "required": ["program_id"]
      },
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      }
    }
  ]
}

Stop guessing. Start knowing what will slip.

Sign up, create a workspace and choose a plan at Stripe Checkout. Then connect Jira and Asana with an API token, or load the sample portfolio to explore every view first.