Arbor
FreemiumDeterministic PR breakage maps for AI-written code
By Tanmay Verma, Founder · Last verified 06 Jul 2026
0 views
Added 5d ago
77/100Safe BetIn short
Arbor — Deterministic PR breakage maps for AI-written code. Best for Solo developers reviewing their own PRs before merge, Tiny teams wanting automated breakage context without code review overhead, AI agent workflows needing a compact, grounded handoff before editing. Free to use.
Is Arbor actually worth it?
LiveSee what real users actually say. We scan live discussions, reviews and complaints across the web and hand you an honest verdict — in under a minute.
3 free scans · no card needed · downloadable report
Editorial Verdict
Best for
Solo developers reviewing their own PRs before mergeTiny teams wanting automated breakage context without code review overheadAI agent workflows needing a compact, grounded handoff before editingEngineers evaluating risk in billing, auth, or data layers
Not ideal for
Teams needing full static analysis or symbolic executionCodebases heavily reliant on dynamic metaprogrammingUsers wanting a traditional code review assistant with LLM judgment
Arbor's deterministic approach is a breath of fresh air in the noisy AI code review space. It gives you concrete, repeatable breakage paths instead of a confidence score. For solo devs and AI agent workflows, it's a practical pre-merge safety net. Just don't expect it to catch logical bugs or runtime errors.
Skip Arbor if Skip Arbor if you need a code review assistant that uses LLM judgment to catch logical bugs or runtime errors, or if your codebase relies heavily on dynamic metaprogramming, reflection, or generated code.
Compare with: Arbor vs Draftbit, Arbor vs AppGyver, Arbor vs Cognition AI
Last verified: July 2026
What's new in Arbor
Checked 2 days agoAcross the latest 5 updates: 5 changelog entries.
ChangelogChangelog·Apr 1Newest
0.9.0 Polish – Operator polish and mobile-first launch pass
Rebuilt landing hero around PR breakage maps, improved mobile layouts, normalized dashboard lifecycle states, and smoothed GitHub sign-in recovery.
ChangelogChangelog·Apr 1Newest
0.8.5 Fix – Runtime hardening and status quality
Added readiness checks, request IDs, timeouts, structured tracing; improved commit-status target URLs; made status-post failures non-fatal.
ChangelogChangelog·Apr 1Newest
0.8.0 Major – Breakage analysis pipeline
Added classifier heuristics across 10 surface categories, upstream/downstream call-path tracing, framework-aware entrypoint detection, and repo rule loading.
ChangelogChangelog·Mar 1
0.7.0 Major – PR breakage product pivot
Reframed product around AI-generated PR context; dashboard shows reachable paths, side effects, next checks; removed overclaiming language.
ChangelogChangelog·Feb 1
0.6.0 Engine – Private engine expansion
Added 4-dimensional scoring (correctness, risk, reliability, maintainability), 21 weighted signals with freshness decay, and conditional verdicts.
What independent users actually report about Arbor
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
49 mentions across 3 sources (Hacker News, App Store, Lemmy).
0% positive100% critical
Recurring strengths
- +Deterministic analysis: same code always yields same result.
- +No LLM judgment: avoids hallucinations and vague confidence scores.
- +Framework-aware: detects Next.js, Express, FastAPI entrypoints.
- +Agent handoff JSON: keeps coding agents scoped to relevant code.
- +Free during public beta with no credit card or limits.
Recurring frustrations
- −No real community feedback exists to validate the tool.
- −No code execution means runtime breakage goes undetected.
- −Limited to static structural analysis—no dynamic or semantic checks.
- −Paid plans for private repos are still missing for production use.
- −Pivot history may worry teams seeking stable tooling.
Patterns worth knowing
No real user feedback available for Arbor across any source
Seen on Hacker News, App Store, Lemmy
Tool's concept is technically sound but unproven in practice
Learning curve
beginnerProductive in ~5 minutes
Hidden costs people mention
- • No hidden costs during beta; future paid plans may introduce scaling limits.
Viability Score
77/100
Safe BetHow likely is Arbor to still be operational in 12 months? Based on 4 signals — momentum (how recently it shipped), wrapper dependency, revenue model, and web presence.
momentum
55
funding runway
80
website health
90
wrapper dependency
100
Last calculated: July 2026
How we score →Key Features
- Deterministic breakage path tracing from diff to routes, jobs, webhooks, helpers, and data writes
- Framework-aware entrypoint detection for Next.js, Express, FastAPI, Axum, Spring
- Agent handoff JSON export for Codex, Claude Code, Cursor
- PR comment with changed scope, reachable paths, likely breakage, unknown edges, first check
- Sensitive path detection via .arbor/security.yml patterns (auth, billing, db, network)
- Unknown edge listing for dynamic imports, generated code, incomplete resolution
- Test-first action naming: smallest useful regression test suggestion
- 14-language support via tree-sitter parsing (JS/TS, Python, Go, Rust, Java, etc.)
- Deterministic run: same code always produces same structural walk
- Open graph core: Rust parsing and graph modules are inspectable
- Per-change path heat map for downstream file impact
- Merge confidence quick-view (public PR URL paste, no signup, no code storage)
- Mobile-first landing hero rebuilt around PR breakage maps (April 2026)
- Dashboard lifecycle states normalized (April 2026)
- Commit-status target URLs improved (April 2026)
About Arbor
FreemiumIntermediateAPI availableWeb · API · Plugin
Arbor is a graph-native code intelligence tool that replaces embedding-based RAG with deterministic program understanding. It parses pull request diffs, builds an abstract syntax graph of the codebase, and traces downstream paths from changed code to identify likely breakage points. Unlike AI code review tools that rely on LLM judgment, Arbor's analysis is structural and repeatable: it walks caller-callee relationships, detects framework entrypoints (Next.js, Express, FastAPI, etc.), and maps changed files to routes, jobs, webhooks, billing flows, and data writes. Arbor is designed for solo developers, tiny teams, and AI agents who need a fast, grounded risk assessment before merging PRs. It posts a single comment on GitHub PRs with a breakage map, known unknowns, and a suggested first test. It also exports an agent handoff JSON that coding agents like Codex, Claude Code, or Cursor can use to stay scoped and avoid wandering the repo. The product pivoted in March 2026 from generic blast-radius analysis to concrete PR breakage context, and the engine now classifies changed code across 10 surface categories. Arbor launched its cloud dashboard and GitHub App in December 2025, and has been in active development since November 2025. The core parsing and graph modules are open-source and inspectable. What makes Arbor different: no code execution, no LLM judgment, no vague ratings. It shows the actual structural impact of a change, surfaces missing edges as unknowns, and gives reviewers and agents a clear action—not a confidence score. Pricing is free for all during public beta (no credit card, no limits), with paid plans coming later for private repos and deeper history.
Behind the Verdict
Arbor fills a specific gap: it gives you a structural, repeatable map of what a PR actually touches — not a guess from an LLM. For solo developers reviewing their own AI-generated PRs, that's gold. The free public beta (no credit card, no limits) makes it a no-brainer to try. The agent handoff JSON is clever: it lets coding agents like Codex or Claude Code work within a bounded scope, stopping them from wandering into unrelated files. The April 2026 polish release (0.9.0) improved mobile layouts and dashboard lifecycle states, making the tool feel more cohesive. Weaknesses: Arbor only works with GitHub at launch. It cannot catch runtime bugs, dynamic imports, or generated code. The public beta has no rate limits documented, but performance on very large PRs or monorepos is unknown. If you need full static analysis or LLM-based code review, look elsewhere. But for quick, grounded risk assessment before a merge, Arbor is hard to beat.
Researching Arbor? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Arbor actually fits — and what changes day-one when you adopt it.
Solo developer reviewing a self-authored PR
You just finished a PR that changes a billing checkout flow. You install the GitHub App, open the PR, and Arbor posts a comment showing the changed scope (checkout.ts, webhook.ts), reachable paths (billing → webhook → retry worker), likely breakage (double-charge risk from non-idempotent webhook), and a first test suggestion (idempotency test for duplicate webhook replay).
Outcome: You catch the potential double-charge before merge and add the suggested regression test, avoiding a production incident.
AI agent using Arbor as pre-edit context
You ask Claude Code to fix a duplicate invoice bug in a billing repo. Before the edit, you run Arbor on the latest PR; it exports an agent handoff JSON with changed scope, likely breakage (retry job enqueues duplicate invoice attempts), and a stop condition ('do not edit auth/session.ts unless the failing test proves it is involved').
Outcome: Claude Code stays scoped, fixes only the relevant files, and passes the regression test — no wandering into unrelated parts of the repo.
Use Cases
- Catch duplicate side effects in billing paths before merging a pricing PR
- Give an AI coding agent a scoped repair brief instead of letting it wander the repo
- Identify all routes, jobs, and webhooks touched by a refactor in a Node.js backend
- Get a quick risk card for any public GitHub PR without signing up
- Flag changes that touch auth tokens, database writes, or payment flows automatically
- Accelerate code review by focusing human attention on the high-risk paths shown by Arbor
Models Under the Hood
none — no LLM in the risk path
as of 2026-07-06
Limitations
- Arbor is a structural graph walk—it does not execute code, so bugs in runtime logic are invisible.
- It cannot resolve dynamic imports, reflection, generated code, or runtime metaprogramming.
- The quality of analysis depends on the completeness of the codebase AST; partial or siloed repos may yield incomplete maps.
- During public beta, there are no stated rate limits, but performance on very large PRs or monorepos is not documented.
as of 2026-07-06
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Arbor tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Public beta
$0/mo
Ideal for
Solo developers, tiny teams, and AI agent tinkerers who want deterministic PR breakage maps without paying anything.
What this tier adds
Free for public and private repos, no credit card, no limits during public beta. Paid plans coming later.
Integrations
GitHub
Where the pricing makes sense
The company stage and team size where Arbor's pricing actually pencils out — and where peers do it cheaper.
Arbor is free for everyone during public beta (all features, no limits). This makes it a perfect fit for solo devs and tiny teams who want a deterministic safety net without upfront cost. Compared to code review tools like CodeRabbit or whatever (paid tiers start at $12/mo/user), Arbor's free tier is unmatched — just note paid plans are coming.
Setup time & first value
How long it actually takes to get something useful out of Arbor — broken out by persona, not the marketing-page minute.
For solo devs: install the GitHub App on your repos (2 minutes), open a PR — Arbor posts a breakage comment within seconds of the webhook. For AI agent workflows: add a step to run Arbor on the PR and feed the agent handoff JSON before the edit (5 minutes). No config required; you can optionally add .arbor/security.yml for sharper notes.
Switching to or from Arbor
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
Migrating in
- →From CodeRabbit or whatever: You can keep using your existing code review tool for LLM commentary and add Arbor for deterministic breakage maps. No migration needed — Arbor runs alongside other GitHub apps.
Resources & Guides
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
- Documentationgetarbor.dev
Docs · Arbor
Full product docs from getarbor.dev
Frequently Asked Questions
Tools that pair well with Arbor
Common stack mates teams adopt alongside Arbor, with the specific reason each pairing earns its keep.
Featured Head-to-Head Comparisons
Alternatives to Arbor
View allUsed Arbor? Help shape our editorial sentiment research.