RigelWhy Rigel
Why Rigel
Keep your agents. Add the chart.
You already have coding agents, reviewers and maybe a developer portal. Rigel is the layer between them and your system: the chart they work from, the blast radius on PRs you turn it on for, and the gates Rigel's own agents have to pass.
GitHub today. GitLab and Bitbucket are on our radar.
Position
Where Rigel sits.
One chart in the middle. Your tools orbit it. Tap any of them.
Rigel · the chart
See·Brief·Govern
AI PR reviewers
Context engines
Developer portals
Dependency bots
Ops AI
The middle band. Agents get context from the chart. Rigel's own agents' changes pass through its gates on the way back.
Your system·Repos·Jira·Slack·CI·Confluence·Your cloud
context out (Brief) · changes back through gates (Govern) · your tools · your system, charted from code (See)
Capability map
Who's built for what.
Typical focus by category. Many tools span several, so treat this as a map, not a scorecard.
If you already pay for Copilot and Dependabot, keep both. Rigel adds what neither has: a map of how your services depend on each other, given to every agent, and gates on what Rigel's own agents merge.
| Capability | AI PR review e.g. CodeRabbit, Greptile, Graphite, Copilot review |
Context engines e.g. Sourcegraph, Augment, Unblocked, DeepWiki |
Coding agents e.g. Claude Code, Cursor, Copilot agent, Devin, Codex |
Developer portals e.g. Backstage, Port, Cortex, OpsLevel |
Dependency bots e.g. Dependabot |
Ops AI | Rigel |
|---|---|---|---|---|---|---|---|
| What they're great at | |||||||
| Line-by-line review comments on every PR | Focus | Not the focus | Varies | Not the focus | Not the focus | Not the focus | Partly — uses your reviewer |
| Writes code from a task | Not the focus | Not the focus | Focus | Not the focus | Not the focus | Not the focus | Partly — fixes, bugs, deps |
| Code search and Q&A | Not the focus | Focus | Varies | Not the focus | Not the focus | Not the focus | Yes — Ask Rigel |
| Ownership, scorecards, a developer front door | Not the focus | Not the focus | Not the focus | Focus | Not the focus | Not the focus | No — keep your portal |
| Dependency alerts and version bumps | Not the focus | Not the focus | Not the focus | Not the focus | Focus | Not the focus | Partly — npm today |
| Incident investigation | Not the focus | Not the focus | Not the focus | Not the focus | Not the focus | Focus | Partly — AWS, supporting |
| Where Rigel is different | |||||||
| Estate-wide, cross-service chart built from code | Not the focus | Varies | Not the focus | Varies | Not the focus | Not the focus | Yes — Node.js / TS today |
| Branch-aware, refreshed on every merge | Not the focus | Varies | Not the focus | Not the focus | Not the focus | Not the focus | Yes |
| Blast radius and risk score on PRs | Varies | Not the focus | Not the focus | Not the focus | Not the focus | Not the focus | Yes — enable per repo |
| Policy gates and supervised merge for agent PRs | Not the focus | Not the focus | Not the focus | Not the focus | Varies | Not the focus | Yes — Rigel's own agents |
| MCP both ways: serves the chart, uses your servers | Not the focus | Varies | Varies | Varies | Not the focus | Varies | Yes — 20 read-only tools |
| Self-host on your own model key | Varies | Varies | Varies | Varies | Varies | Varies | Yes, in Beta — Beta |
| Agent-to-agent (A2A), with data scopes | Not the focus | Not the focus | Not the focus | Not the focus | Not the focus | Not the focus | Yes, in Beta — Beta |
| Where Rigel is weaker today | |||||||
| Languages beyond Node.js/TypeScript | Varies | Yes | Yes | Varies | Varies | Varies | Partial; Java, Python, Go Coming soon (details) |
| Code hosts beyond GitHub | Yes | Yes | Varies | Yes | Varies | Varies | Not yet; GitLab and Bitbucket on our radar |
| Service ownership, scorecards, catalog | Not the focus | Not the focus | Not the focus | Yes | Not the focus | Not the focus | Not the focus; keep your portal (catalog sync on our radar) |
| Hosted, no-install trial | Yes | Yes | Yes | Yes | Yes | Varies | Not yet (Cloud Coming soon) |
Key: core focus · varies by tool, or partly · not the focus, or not yet
Each category does one job well. Rigel isn't trying to replace any of them.
The chart underneath them all: built from code, branch-aware, refreshed on merge, served over MCP, with gates on the agent PRs Rigel opens.
Keep what works. Point your agents at the chart and let Rigel govern its own changes.
Comparisons
"Don't we already have this?"
Probably something nearby. Here's what's different, and the mechanism behind it.
You might use AI review bots on pull requests.
Great at — Fast, line-level feedback on every diff.
Rigel differs — It doesn't compete on comment quality. It governs the PRs its own agents open, and says why when it holds one.
Use together — For code changes Rigel's agents make, the supervisor requires GitHub Copilot code review as the reviewer of record.
How it works
Gates depend on which flow opened the PR. Semver and path gates are deterministic. The fixer loop is supervised and capped at four iterations. A [needs-review] title is a manual brake no gate overrides, and every green PR Rigel declines gets a decision comment.
Dependency and docs PRs are gated deterministically and don't need a reviewer. Any PR can also get a transparent 0–100 risk score once you enable Impact for that repo.
Backed by: PR Supervisor · PR Fixer · Repo Guard · .github/** write ban · Blast Radius
You might use a code search or semantic context engine.
Great at — Finding the right code fast in a large codebase.
Rigel differs — A persistent, branch-aware model of your service topology: services, APIs, queues, IaC and dependencies. Not only a semantic index.
Use together — Keep your search. Ask Rigel the system questions: who consumes this endpoint, package or queue?
How it works
Onboarding runs seven analysis passes per service, plus an AST code graph that uses no LLM. On every merge to a tracked branch, Rigel re-analyzes only the affected service documents, and any agent can query the result over MCP.
Node.js and TypeScript estates get the full chart today. Java, Python and Go service discovery is Coming soon.
Backed by: Deep Survey · branch-aware chart · Living Docs · Rigel MCP
You might use autonomous or background coding agents.
Great at — Turning a task into working code, quickly.
Rigel differs — It's the control plane above them. It briefs them with the chart over MCP, and Impact analysis can score their PRs.
Use together — Connect Claude Code, Cursor or any MCP client in one config entry.
How it works
20 read-only tools, including find_consumers and cross_repo_impact. Run it over stdio locally or as stateless Streamable HTTP at /mcp. Remote endpoint auth is Coming soon, so run it inside your network for now.
Rigel's own agents go further: every PR they open passes the supervisor's gates. Supervising PRs opened by external coding agents is Coming soon.
Backed by: Rigel MCP · Blast Radius · PR Supervisor · Playbooks
You might use a service catalog or developer portal.
Great at — Ownership, scorecards and a front door for developers.
Rigel differs — Its catalog is derived from code, not maintained by hand.
Use together — Your portal's catalog stays where it is. Check it against Rigel's code-derived chart.
How it works
Deep Survey discovers services from manifests and source. Constellations group repos into one system view, and Living Docs keep it current on every merge. Catalog sync with portals is on our radar.
Backed by: Deep Survey · Constellations · Living Docs
You might use a bot that raises dependency alerts and bumps.
Great at — Spotting vulnerable or outdated packages, repo by repo.
Rigel differs — It reasons over open alerts with the chart and opens one type-checked PR, with transitive dependencies pinned and its reasoning attached.
Use together — Keep Dependabot raising alerts. Rigel turns them into one governed PR.
How it works
Patch and minor bumps that touch only manifests and lockfiles can self-merge. Majors are held for a person unless policy allows them, and CI and infra paths are always denied.
npm ecosystem today. Maven/Gradle, pip/Poetry and Go modules are Coming soon.
Backed by: Dependency Upgrade Advisor · semver gate · path gate
You might use an AI assistant for incidents.
Great at — Investigating incidents across logs, metrics and alerts.
Rigel differs — Ops isn't Rigel's lead. Its debug agent brings the chart to an incident, so you see which service and code path is involved.
Use together — Keep your on-call tooling. Open a Rigel session when you need the code side.
How it works
Read-only sessions correlate your AWS logs and metrics with code context. No edit, write, shell or web tools. AWS only today.
Backed by: Ops debug agent · staging alarm triage (AWS)
Self-host, on your own model account.
Full breadth (map, plan, impact, govern) in your own cloud, on the Anthropic API or Claude through your AWS account. Embeddings use Voyage AI under your own Voyage account.
Rigel Enterprise Beta · air-gapped install Coming soon · Enterprise →
Governed A2A, not open chatter.
Rigel speaks A2A on the official SDK: agents carry a data scope, peers sit in an auditable registry, and every outbound request passes a critic that fails closed.
A2A live agents · registry · depth-capped mesh · Autopilot →
Two more categories nearby
Docs automation. Rigel refreshes internal architecture docs and OpenAPI specs across many repos, delivered as one reviewable rolling PR per branch, with a scheduled drift check. It's for your engineers and agents, not a customer-facing docs site.
Requirements AI. Rigel Plan drafts solution designs grounded in your real service graph, with a critic that flags claims the chart doesn't support. Rigel Plan →
Why this is hard
Why a single agent vendor won't build this for you.
The map is built from your code, across every repo, and kept current on every merge. That history, and the policies you set on top of it, belong to your estate, not to one agent. Rigel is neutral: it briefs Claude Code, Cursor and any MCP client the same way, so you can switch agents without rebuilding the map.
Use together
Keep what works. Add the chart.
Your coding agents
One config entry connects any MCP client. Turn on Impact per repo to score their PRs.
The one line
claude mcp add --transport http rigel \ https://rigel.internal.example/mcp
Illustration. Run it inside your network until remote auth ships.
Your reviewer
For code changes Rigel's agents make, GitHub Copilot code review is the reviewer of record. Rigel adds CI, thread, semver and path gates around it.
Your portal
Your catalog stays where it is. Rigel gives you the code-derived chart to check it against.
Your dependency alerts
Open Dependabot alerts become one reasoned, gated PR. npm today.
Your workflow
Jira for bugs and requirements, Slack for the flight log, Confluence for publishing (optional).
Your cloud
Read-only debug sessions against your AWS accounts, with the chart in hand.
See the control plane on your own system.
We'll chart a sample estate, or one of your repos.
Who builds it → Company