The project control plane for agentic development
Plans, Projects, Issues, and Testing for agentic teams
Claude Code, Codex, Cursor, Antigravity — your coding agents create issues, run tests, triage bugs, and drive work to Done, while your team steers requirements, goals and approvals. Run your agents manually, semi-autonomous, or fully autonomous: the control plane's gates and statuses control the flow, and humans can take the wheel at any time — from the coding harness chat or the Levr UI.
One graph for issues + tests · every function agent-operable via MCP · mix any agents & harnesses · every action attributed
- mcp · get_issue
AGENT · CLAUDE CODE
Read LEV-892 + acceptance criteria — starting implementation
- mcp · create_test ×3
AGENT · CLAUDE CODE
Authored 3 test cases covering AC-1…AC-3
- mcp · record_results
AGENT · CLAUDE CODE
Run complete — 12 pass · 1 fail → defect LEV-897 filed + linked
- levr ui
HUMAN · SARAH (LEAD)
Reprioritized LEV-897, edited AC-2 wording — agent continues
Gates green: all ACs covered, tests passing — ready for Done
Works with every popular coding agent — and lets you mix them on the same projects
Dashboards + reporting
Your agents move fast. See it all at a glance.
When agents do the work, dashboards are how humans keep up. Live widgets for throughput, cycle burndown, blocked work, test health, and who — human or agent — is carrying what. No report requests, no exports: it is the same live data the agents are writing to.
- Throughput and burndown, live — created vs completed, on track or not
- Needs-attention surfacing: blocked, stalled, and uncovered work
- Test health at a glance: tests per issue, automation rate, pass trends
- Workload by person and by agent — with every event attributed
Open
218 ▼ 15
38 created this week
In progress
42 ▲ 6
avg age 4.2d
Blocked
7 ▼ 3
oldest 6d
Completed
511 ▲ 38
58% of all work done
Throughput
net backlog −23/wk
Cycle burndown
Cycle 14 · 2d left
72% complete · on track · scope +1 pt
Test health
tests per issue
4.6×
7,532 test cases · 94% automated · 457 manual
Workload
12 unassigned
Needs attention
7 blocked · 12 uncovered
- Blocked
Stripe webhook retries flaky on staging
LEV-897 · High · idle 3d
- Stalled
3-D Secure challenge times out on mobile
LEV-903 · Medium · idle 14d
activity · 1,284 events this week — 62% by agents · humans closed the last 41 approvals
Why teams switch
Agentic development breaks human-scale tools
Adopting Claude Code, Codex, or Cursor is the easy part. Scaling them is where your project software — built for humans typing into forms — starts to fail. Levr was built for what comes next.
Your agents outrun your tracker
Claude Code ships a branch in twenty minutes; the board finds out on Friday. Work happens in the harness, status lives somewhere else, and the plan drifts from reality a little more every sprint.
With Levr: In Levr the agent reads the issue, works it, and updates it — plan and reality are the same object, updated in real time.
Verification becomes the bottleneck
Agents multiply output, not confidence. Who writes the tests for agent-written code? Where do the results live? Bolting a test tool onto your tracker means a sync bridge and two versions of the truth.
With Levr: Tests, runs, and results live in the same graph as the issues — agents author tests against acceptance criteria, execute runs, and record results in one loop.
Nobody can say who did what
When agents and humans share a codebase, "who changed this and why" stops being a rhetorical question. Autonomy without an audit trail is how trust dies.
With Levr: Every action — human or agent — is attributed and timestamped in one activity trail. Delegate the work, keep the accountability.
Projects + Issues
Issue tracking built for humans and agents.
Epics, stories, cycles, triage — where every object is equally writable by your team and your agents. The agent reads the issue and its acceptance criteria, works it, and updates it. The plan and reality never drift, because they are the same object.
- Typed hierarchy: Epic → Feature → Story, Defects linked to what they regress
- Structured acceptance criteria — the contract agents implement against
- Triage inbox, boards, relations graph, bulk create
- Every change attributed: agent or human, with full history
Claude Code
mcp ⇄ levr
> Break the caching epic into stories and start the first one
⏺ levr - manage_issues (MCP)(create: 3 stories ← epic LEV-140)
⎿ Created LEV-142 · LEV-143 · LEV-144, criteria attached
⏺ levr - transition_issue (MCP)(LEV-143 → In Progress)
⎿ Assigned to claude-code · attributed as agent
⏺ Board updated — starting on LEV-143.
- LEV-142Implement Redis CachingHAI
- LEV-143Cache User ProfilesActive (Claude Code)
- LEV-144Update API docsAI
activity · 3 issues created + 1 transition — by agent:claude-code · just now
Any autonomy level
Manual, semi, or fully autonomous. The process holds.
Autonomy isn’t a switch in Levr — it’s how you run your agents. Work the board yourself, pair agents with human checkpoints, or let them run end-to-end. Either way it’s the same control plane: workflow states and quality gates move every issue and test through the same process, and nothing reaches Done until the gates say so.
- Workflow states and gates enforce the process, whoever is driving
- Autonomous agents are held to the same bar as humans — tests green before Done
- Take the wheel anytime — humans and agents work the same live objects
- BYO agents — Claude Code, Codex, Cursor, Antigravity, any MCP client
Claude Code
mcp ⇄ levr
⏺ Implementation complete — moving LEV-903 to Done.
⏺ levr - transition_issue (MCP)(LEV-903 → Done)
⎿ Gate holds: coverage 2/3 green — stays In Review
⏺ levr - manage_runs (MCP)(re-run TC-90 after fix)
⎿ 3/3 green — transition to Done allowed
⏺ levr - transition_issue (MCP)(LEV-903 → Done)
⎿ Done · attributed as agent:claude-code
LEV-903 · workflow
Same gates, however you drive
Manual
Humans work the board, agents assist
Semi-autonomous
Agents execute · humans check in at the gates
Fully autonomous
Agents run issue → code → tests → done
audit · every action attributed — agent:claude-code · human:sarah · 14 events today
Heterogeneous by design
Any agent. Any harness. Mix them freely.
Levr’s control plane is heterogeneous: your team can choose any of the popular coding agents and harnesses — and mix them in the same projects, all working in concert on the same issues, tests, and gates. Use the right agent for each job, or route workloads by best fit and cost. No lock-in, no silos, and whatever ships next already works — it just speaks MCP.
- Claude Code, Codex, Cursor, Antigravity, Copilot, Grok, Kimi, Qwen, GLM, OpenCode…
- Mix agents and harnesses in one project — same issues, same tests, same gates
- Route work to the best-fit agent per task, or optimize for cost
- One audit trail across the whole fleet — every action attributed to its agent
levr - transition_issue (MCP)(LEV-921 → In Progress)
Webhook retries — implementing against 3 ACs
levr - manage_tests (MCP)(create TC-96…TC-99 ← LEV-922)
Cart edge cases covered — running now
levr - transition_issue (MCP)(LEV-923 → In Review)
Checkout polish done — PR #131 linked
different agents, different harnesses — one MCP surface
- LEV-921Stripe webhook retriesagent:claude-codeIn Progress
- LEV-922Cart quantity edge cases — testsagent:codexIn Progress
- LEV-923Checkout UI polishagent:cursorIn Review
- LEV-924Bulk triage of low-sev defectsagent:qwenQueued · cost-routed
routing · best-fit agent per task — LEV-924 routed to the cost-optimized fleet · all four in one audit trail
Native testing
Tests live with the work. Coverage is a relationship, not a report.
A full test-management layer in the same graph as your issues — no add-on, no connector, no second tool. Tests link to acceptance criteria; a failing test files a defect on the same board; release readiness is one view. This is the loop “Linear plus a test tool” cannot close.
- Suites, shared steps, preconditions, data-driven cases
- Author as steps, Gherkin/BDD, or free-text — per case
- Coverage links from each acceptance criterion to its tests
- Defects are issues — filed, linked, and triaged in one graph
Claude Code
mcp ⇄ levr
> Write tests for LEV-892's acceptance criteria and run them
⏺ levr - manage_tests (MCP)(create TC-88…TC-90, Gherkin ← AC-1…AC-3)
⎿ Coverage linked: 3 criteria → 3 tests
⏺ levr - manage_runs (MCP)(execute TC-88…TC-90)
⎿ TC-90 failed → defect LEV-897 filed + linked
⏺ Coverage 3/3 · passing 2/3 — LEV-897 is on the board for triage.
Acceptance criteria → tests
covered 3/3 · passing 2/3- AC-1Card declines surface a retryable errorTC-88Passed
- AC-23-D Secure challenge completes checkoutTC-89Passed
- AC-3Webhook retries are idempotentTC-90Failed
TC-90 failed → defect LEV-897 filed, linked to test + issue — same board, same graph
by agentAgent-run execution
Your agent runs the tests — and records the proof.
The write-path competitors lack: agents start runs, record results, file the regressions they find, and finish with a summary — straight from the harness over MCP. Humans watch the same run fill in live, triage failures, or take over. Quality stops being the bottleneck agents create.
- start_run · record_results · finish_run — exposed as agent tools
- Manual and automated execution in one run model
- Append-only attempts — history is never overwritten
- Live rollups, pass-rate trends, changed-test integrity flags
Claude Code
mcp ⇄ levr
> Run the checkout regression and file what you find
⏺ levr - manage_runs (MCP)(start: "Stripe checkout — regression")
⎿ Run #218 started · 10 tests
⏺ levr - record_results (MCP)(TC-88 pass · TC-89 pass · TC-90 fail)
⎿ Defect LEV-897 filed ← TC-90
⏺ levr - finish_run (MCP)(summary → quality snapshot)
Run #218 · live
9 / 10 executedPass-rate trend · 14d
humans see the same run, live — triage or take over anytime
Exploratory testing
Session-based exploration, with an AI debrief.
Real SBTM, native: time-boxed charters, a typed session log with severities and screenshots, and one-click promotion of any finding into an issue or test. End the session and the AI drafts your PROOF debrief — Past, Results, Obstacles, Outlook, Feelings — ready to edit and save. No other tracker or test tool ships this.
- Charters, timers, and structured entry types
- Promote a note to a linked issue or test in one click
- AI-drafted PROOF debrief + time-distribution estimate
- Sessions, findings, and follow-ups all in the same graph
Claude Code
mcp ⇄ levr
> End my exploration session and promote the coupon finding
⏺ levr - manage_exploration_items (MCP)(promote finding → issue LEV-901)
⎿ Linked to session · sev high
⏺ levr - manage_explorations (MCP)(end EXP-31 · draft PROOF debrief)
⎿ AI debrief drafting — review in Levr
⏺ Session ending — debrief will be ready to edit and save.
Mission
Probe checkout edge cases around coupons & tax
- FINDINGCoupon field accepts expired codes on retrysev · highPromoted → LEV-901
- OBSERVATIONCheckout total re-renders twice on quantity changescreenshot.png
- QUESTIONShould tax recalc fire before or after coupon apply?Promoted → TC-93
End session — AI PROOF debrief
drafting…Past: coupon + tax flows, 3 device sizes · Results: 1 high-sev finding, 1 new test · Obstacles: staging Stripe keys · Outlook: retest LEV-901 fix · Feelings: confidence 7/10▌
Code, PRs + CI
Every result knows its commit.
Pull requests are first-class objects — auto-linked from branches and commits, closing their issues on merge. CI results stream in as automation runs bound to commit, branch, and PR, and a failing spec files a linked defect automatically. Coexist with GitHub and Jira while you migrate on your own schedule.
- GitHub Issues two-way sync + PR auto-linking with close-on-merge
- JUnit ingestion from any CI — GitHub Actions first-class
- Streaming results, Vitest reporter, tq push CLI
- Jira sync with status & priority mapping for gradual migration
Claude Code
mcp ⇄ levr
> LEV-892 is green locally — ship it
⏺ Bash(git push -u origin feat/lev-892-stripe)
⎿ Branch pushed · PR #114 opened
⏺ Levr auto-linked PR #114 ← LEV-892, closes on merge.
⏺ CI is streaming into run #219 — watching for failures.
GitHub Actions → automation run #219
streamingci › junit ingest · commit a3f92e1 · 142 results
ci › 139 passed · 2 skipped · 1 failed
levr › webhook-replay.spec failed → defect LEV-897 filed · linked to test + PR
How it works
How the agentic workflow operates
Levr acts as your team's project manager — tracking progress, coordinating tasks, and ensuring your human devs and AI coding agents have the context they need to operate at full velocity.
Acceptance criteria
- AC-1 · profile reads hit cache before Postgres
- AC-2 · cache invalidates on profile update
- AC-3 · p95 profile read under 25ms
created by human:sarah — the contract your agents implement against
For every role
Built for every role on your team
Whether you write the code, shape the product, guard the quality, or lead the team — Levr gives you the view and control you need.
DEVELOPER
Give your agents a project, not just a prompt.
Full project context — gates, tasks, prior runs, shared memory. Your coding agent knows where it is in the work, what came before, and what the gate requires to close.
PRODUCT MANAGER
See and shape the plan before the code.
Every agent-generated plan surfaces as a Levr project you can inspect, reshape, and gate — before a line is written. You're in the control plane without being in the way.
QA ENGINEER
Quality at agent speed, without losing control.
Agent-authored suites, automated execution, human gate control. Manual and automated tests in one system — tied to the same project context your agents are working in.
ENGINEERING MANAGER
Manage your AI workforce like your human one.
Agent velocity, pipeline health, output quality, and compounding improvement — in real time. For the first time, your AI workforce is measurable, observable, and improvable.
Compare
The only platform where the agent closes the loop
Linear gives agents issues without a quality loop. Jira buries the loop under add-ons and latency. TestRail has the tests but not the work. Levr is one graph, one API, one control plane.
| Capability | Levr | Linear | Jira | TestRail |
|---|---|---|---|---|
| Agent surface (MCP) | ✓ Designed around it — co-equal with the UI | ◐ Official server, added on | ◐ Atlassian MCP + Rovo, added on | ◐ Emerging; write-path gaps |
| Agents create & resolve issues | ✓ | ✓ | ✓ | — No native issues |
| Agents author, run & record tests | ✓ start_run · record_results · finish_run | — No tests in product | ◐ Only via add-ons (Xray/Zephyr) | ◐ API yes; agent surface immature |
| Issues + tests in one graph | ✓ Coverage is a native relationship | — | ◐ Two systems inside one product | — Defects sync out to Jira |
| Agent identity & full attribution | ✓ BYO agents, one audit trail | ◐ Agents-as-teammates seats | ◐ Rovo agents | — |
| Mix agents & harnesses on one project | ✓ Heterogeneous by design — route by fit or cost | ◐ Own agent platform emerging | — Pushes toward Rovo | — |
| Fast, instant UI — no page-load lag | ✓ | ✓ The benchmark | — | — |
Ready to build with your agentic team?
Join the teams building the future with humans and coding agents working together in one system.
No credit card required. Free during beta.