Agentic DORA

Partial. Core Agentic DORA / throughput is shipped; some capabilities (GitHub review-state ingestion, full first-pass metrics) are still in progress.

Measure the speed and quality of your software factory with Agentic DORA metrics. This dashboard tracks issues from intent to merge, shows throughput per team member, and surfaces first-pass merge rates.

Overview

The Agentic DORA panel reports four canonical metrics on the Performance dashboard:

Issues per operator-month - count of distinct issues resolved per calendar month, grouped by GitHub login (the PR author). Frames agent-assisted work from the human steering perspective.
Intent-to-merge time - median (p25/p75) duration from issue creation to PR merge. Approximates intent as the first factory_events observation for that issue.
First-pass merge rate - share of agent-authored PRs whose issue had no work-item.rework event. This is a partial: GitHub review-state ingestion (tracking actual review blockers) will refine this in a future release.
Review burden ratio - human review time / (review time + agent engineering time). Uses human.review-started → human.review-completed pairs.

Metrics Detail

Issues per Operator-Month

The headline metric: how many distinct issues does each team member resolve per calendar month?

Data source: agent_pr_attributions table, grouped by GitHub PR author
Filter: Merged PRs only. Unmerged branches are excluded.
Time window: Bucketed into calendar months. The dashboard supports 7d, 30d, and 90d views.

// Example query shape
const issuesPerMonth = await getIssuesPerOperatorMonth({
  workspaceId: org.id,
  mergedAfter: thirtyDaysAgo,
  mergedBefore: now,
})

// Returns:
// [
//   { operator: 'octocat', month: '2026-06', count: 12 },
//   { operator: 'monalisa', month: '2026-06', count: 8 },
// ]

Intent-to-Merge Time (Median, p25/p75)

How fast does an issue move from filed to resolved?

Intent approximation: First factory_events.occurredAt for that issue (e.g., work-item.started from the first session attempt).
Merge event: agent_pr_attributions.mergedAt timestamp.
Percentiles: Median, p25 (fast quartile), p75 (slow quartile).

This is intentionally approximate. The tightest signal would be the exact timestamp the human filed the issue (from GitHub API), but platform-side our closest proxy is the first event we observe. For SDLC-speed evaluation this is close enough, and future improvements can refine precision further.

const intentToMerge = await getIntentToMergeTime({
  workspaceId: org.id,
  operator: 'octocat', // optional filter
  mergedAfter: thirtyDaysAgo,
})

// Returns:
// {
//   p50_ms: 172800000,   // 2 days
//   p25_ms: 86400000,    // 1 day
//   p75_ms: 432000000,   // 5 days
// }

First-Pass Merge Rate

What percentage of agent-authored PRs resolved their issue without rework?

Numerator: Merged PRs with no work-item.rework event for the issue.
Denominator: Total merged PRs.
Status: Partial. True first-pass depends on GitHub pull-request review state ingestion (to see "changes requested" markers), which is not yet persisted.

Current implementation uses work-item.rework as a proxy. Incoming reviews are visible in rensei if wired through Layer 6, but they are not yet queryable via this metric.

const firstPassRate = await getFirstPassMergeRate({
  workspaceId: org.id,
  mergedAfter: thirtyDaysAgo,
})

// Returns:
// { rate: 0.85 }  // 85% first-pass

Review Burden Ratio

What share of engineering time is spent in human review vs. agent work?

Review time: Sum of human.review-completed.occurredAt - human.review-started.occurredAt for all reviews in the period.
Agent engineering time: Sum of work-item.completed.occurredAt - work-item.started.occurredAt per issue, across all issues.
Ratio: Review time / (review time + agent time).

This metric is also partial: it depends on review-event coverage (whether reviewers' PR comments flow through Layer 6) and cannot see agent time outside platform sessions.

const reviewBurden = await getReviewBurdenRatio({
  workspaceId: org.id,
  mergedAfter: thirtyDaysAgo,
})

// Returns:
// { ratio: 0.22 }  // Reviews account for 22% of total time

Data Sources

All metrics are built on two foundations:

agent_pr_attributions table - Rows: (issueId, prUrl, prRepo, mergedAt, authorGithubLogin).
factory_events table - work-item and review-completion events. Filtered by event type and issue association.

Both tables are filled by the factory-events pipeline on session completion.

Display & Filtering

The dashboard exposes these metrics in a Performance → Agentic DORA panel (WFE/OPS personas) with:

Time window selector - 7d, 30d, 90d (configurable window in the background filter)
Operator filter - optional; drill down to one GitHub user's throughput
Repo filter - optional; restrict to one GitHub repo
Sparklines - trend line for issues/month and intent-to-merge p50

Known Limitations & Roadmap

First-pass rate is incomplete. No GitHub pull-request review state ingestion yet. A future release will add review-state schema + ingestion so true "changes requested" blockers are counted.
Review burden depends on Layer 6 wiring. If reviewers don't comment through the platform, review events don't emit. This is configuration-dependent.
Agent time is session-scoped. Work outside platform sessions (e.g., manual CLI invocation) is invisible to these metrics.

API Route

Endpoint: GET /api/factory/issue-throughput?workspaceId=<id>&mergedAfter=<iso>&operator=<login>

Returns all four metrics in one response for dashboard efficiency.

curl -H "Authorization: Bearer $RENSEI_API_KEY" \
  'https://api.rensei.ai/api/factory/issue-throughput?workspaceId=ws_123&mergedAfter=2026-05-03T00:00:00Z'

Response:

{
  "issuesPerMonth": [
    { "operator": "octocat", "month": "2026-06", "count": 12 }
  ],
  "intentToMergeMs": {
    "p50": 172800000,
    "p25": 86400000,
    "p75": 432000000,
    "eventCount": 45
  },
  "firstPassMergeRate": 0.85,
  "reviewBurdenRatio": 0.22
}

PR Attribution - Foundation for agent-authored PR tracking; required for all four Agentic DORA metrics
Code Survival - Quality correlation: first-pass merge rate and code survival at 30 days are complementary quality signals
Routing Intelligence - Thompson Sampling uses intent-to-merge signal from these metrics to bias toward faster-shipping arms
Phase Breakdown - Cycle time per phase (more granular than intent-to-merge)
Rework & Escalation - First-pass rate correlates directly with rework count

On this page