Mainline
Mainline is Git-native agent memory: coding agents save developer intent and decisions as Git refs and notes so the next agent inherits
The premise is sound: context an agent can't see is context it will re-litigate, and Mainline puts that context where engineering teams already sync. Today you get the open-source core — CLI, Git refs and notes, agent hooks, the skill framework, and documented setups for Codex, Claude Code, Cursor, Copilot, and Windsurf — plus a live self-dogfooded Hub you can inspect before installing. Go in clear-eyed: hosted PR intent summaries and audit workflows are the Team and Enterprise layers, both
Verified 1d ago · liveness 77/100 · cite: rightaichoice.com/tools/mainline
- AI-heavy engineering teams that want repository-owned context before agent edits reach review
- Teams running two or more coding agents that need a shared history of decisions
- Developers who keep retrying approaches a previous agent already abandoned
- Reviewers who want the goal and reasoning attached to an agent-generated diff
- Solo developers on short tasks where nobody picks up the thread later
- Teams that want agent conversations stored verbatim rather than compressed into intent
- Buyers who need hosted PR review guardrails shipping today — Team Cloud is listed as Planned
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Mainline if you don't use Git as your version control system, or if you need hosted PR review guardrails or audit exports now — the Team Cloud and Enterprise layers are still published as Planned.
The Enterprise layer is where self-hosted or dedicated deployment, SCM and CI integration, policy controls and audit exports sit — all Planned, so if your security review requires those, budget for a wait or an
The Open Source tier is $0/mo and covers the CLI, Git refs and notes storage, intent records, local hub and export surfaces, and agent workflow docs — cheaper than any hosted agent-memory or AI PR-review subscription, and the right starting point for solo builders and small teams. Team Cloud and Enterprise are published as Planned with no prices, so budgets for hosted collaboration, policy controls or audit exports can't be planned from the pricing page yet. Compare against hosted memory
In short
Mainline — Mainline is Git-native agent memory: coding agents save developer intent and decisions as Git refs and notes so the next agent inherits. Best for AI-heavy engineering teams that want repository-owned context before agent edits reach review, Teams running two or more coding agents that need a shared history of decisions, Developers who keep retrying approaches a previous agent already abandoned. Free to use.
What's new in Mainline
Checked todayAcross the latest 4 updates: 1 launch and 3 changelog entries.
Category capture launch pages
Added definition pages for coding agent memory and repo memory for AI agents, plus the Mainline Agent Memory Eval, glossary, design partner page, and integration docs for Codex, Claude Code, Cursor, GitHub Copilot and Windsurf.
mainline.sh canonical SEO
Moved the public site to mainline.sh as the canonical domain, added technical SEO files, and published the first category pages around repo memory, engineering intent memory, and intent-aware AI PR review.
Multilingual public site
Added static Chinese and Spanish routes for the main website, docs, spec, install, comparison pages, and the first repo-memory essay.
Website repo and first landing page
Initialized the standalone Astro website repo so the product repo can stay focused on CLI, protocol, agent workflow, docs, and release engineering.
What people actually say about Mainline — is it worth it?
We scanned public community sources for Mainline on Jul 15, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
Viability Score
How well maintained and how widely used is Mainline? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Stores developer intent records as Git refs and notes inside your repo
- Human CLI: mainline preflight --json, start, append, and seal
- Inspection CLI: mainline hub open, log, show <intent_id>, and gaps
- Agent protocol: mainline context --current --json, start, append, seal
- Agent hooks pull repo intents into context at task start and before handoff
- Skill framework teaches agents when to read, when to write, and when to stop for human judgment
- Records tried-and-abandoned approaches so future agents skip dead ends
- Detects logic conflicts from recorded intent before they become Git conflicts
- Annotates high-risk code traps and module constraints before an agent edits
- Shows reviewers the original goal, reasoning path, and key decisions behind a diff
- Intent travels through fetch, branch, merge, and fork without a separate database
- mainline init --actor-name writes .mainline/config.toml, configures Git refs, creates an actor identity, installs agent
- mainline doctor --setup verifies the install; installer checks the GitHub Release archive against checksums
- Live self-dogfooded Hub (272 intents, 236 merged, 4 proposed as of Jun 19, 2026)
- Public site available in English, Chinese, and Spanish
About Mainline
Mainline is a Git-native intent record system for teams already running coding agents on production code. Rather than piping full agent transcripts into a separate memory store, it compresses the engineering judgment that actually matters — goals, tradeoffs, pivots, abandoned paths, and no-go zones — into intent records held inside your Git repo as refs and notes. Agents read those records at task start and write fresh judgment back when the work is done, and the records travel through fetch, branch, merge, and fork without a hosted service. The daily loop splits between humans and agents. People run `mainline preflight --json` to pull repo history, decisions, and risks before starting, then `mainline start "Clean up old export"`, `mainline append "Keep legacy CSV until customer migration finishes"`, and `mainline seal` to write judgment back. Agents get the matching protocol through hooks and a skill framework, with integration docs for Codex, Claude Code, Cursor, GitHub Copilot, and Windsurf, so each agent knows when to read, when to write, and when to stop and ask a human. `mainline init --actor-name "alice"` writes `.mainline/config.toml`, configures Git refs, creates an actor identity, and installs agent guidance; `mainline doctor --setup` verifies the install, and the installer checks the GitHub Release archive against checksums. The project dogfoods itself. Its live Hub is generated by Mainline and shows 272 intents, 236 merged, 4 proposed, across 282 files and 6 actors, last updated Jun 19, 2026. The split is the interesting part: 236 merged intents explain why the code became what it is, while the 4 proposed ones show what agents and people are mid-flight on right now. Because the records live in refs and notes, nothing leaves the repo — no new memory database, no platform lock-in, no verbatim transcript dump. Mainline is a public alpha aimed at teams that won't accept a separate memory service. Chat logs run too long, PR descriptions arrive too late,
Behind the Verdict
Pick Mainline when your team runs two or more coding agents against the same codebase and has started losing the thread. The concrete payoff is the abandoned-path record: if one agent tries a migration, backs out, and seals the reason, the next agent reads that and skips the dead end instead of rediscovering it. That's a real cost you feel every sprint. We'd also reach for it on long-lived modules where the code looks odd and the comments don't explain why. Module constraints and no-go zones attached to the repo beat a wiki page nobody opens. Where it bites: adoption is the whole game. Intent records only earn their keep when people and agents actually seal judgment after finishing work — a repo with sparse records is just a slightly nosier Git history. If your team won't change its habit loop, this stays an install you forget about. Pass if you want verbatim agent conversations stored and searchable. Mainline deliberately compresses transcripts into intent, so anything you needed word-for-word isn't there. Pass too if you need hosted PR review guardrails shipping today — the Team Cloud layer is still Planned, not product. The closest alternative is a hosted agent-memory service you query over an API. That wins on cross-repo search and dashboards out of the box; Mainline wins on ownership, since memory rides the same fetch and merge path as the code and dies with the repo rather than with a vendor. For Git-centric orgs the tradeoff usually lands on Mainline. One more caveat: this is public alpha with an open-source core, and the vendor runs design-partner conversations to shape the Team layer. That's a reasonable moment to adopt if you want influence over the roadmap — less reasonable if you need procurement-ready SLAs and audit exports this quarter.
Researching Mainline? 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 Mainline actually fits — and what changes day-one when you adopt it.
Install Mainline with the one-line script, run mainline doctor --setup to verify the checksummed release, then mainline init --actor-name for each contributor and roll out the documented Claude Code and Cursor setups to the team.
Outcome: Every agent pulls repo intents before it touches auth, billing or data-model code, and each meaningful task ends with a sealed intent that the rest of the team fetches on their next pull.
Before editing a legacy export module, run mainline preflight --json to read repo history, then mainline show <intent_id> on a prior sealed intent.
Outcome: You see that a previous agent already abandoned an approach and why, so you skip the dead end instead of rediscovering it three hours into a refactor.
Open the repo's self-hosted Hub to read the 236 merged and 4 proposed intents covering a module, then review the PR against the goal and reasoning path recorded for it.
Outcome: Review shifts from reading code cold to reading intent, and logic conflicts between two agents' changes surface from the records before they become merge conflicts.
Use Cases
- Record agent intent and decisions alongside code in Git repos to preserve context across sessions.
- Retrieve historical decisions and constraints before editing production code to avoid repeated dead ends.
- Detect logic conflicts between agent changes before Git merge conflicts arise.
- Annotate high-risk code modules with explicit constraints that agents must respect.
- Review agent-generated PRs with original goals and reasoning attached for better human oversight.
- Collaborate on agent decisions across branches via fetch, branch, merge, and fork of intent records.
- Self-host your team's own intent Hub to inspect historical decisions, risks, and work in progress.
Limitations
- Mainline is an open-source CLI tool in public alpha; it runs locally and stores data in Git refs and notes inside your repo, so it is oriented toward Git-based workflows.
- Context retrieval requires agents to call the CLI before non-trivial edits — the docs list required contexts for architecture changes, refactors, migrations, deletions, auth, billing, data model, permissions, release, CI, and cross-file behavior changes.
- Mainline saves intent and decisions, not code or AI chat logs, and its value depends on adoption so that the repo carries enough intent records to help future agents.
- The Team Cloud layer (hosted review workflow, PR intent summaries, related prior decisions, open risks and anti-patterns, team search, review guardrails) and the Enterprise layer (self-hosted or dedicated deployment, SCM and CI integration, policy controls, audit exports) are both published as Planned, so those capabilities are not shipping today.
as of 2026-10-09
Verification history
We have re-verified Mainline 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 9 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Mainline tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0/mo
Ideal for
Individuals and small AI-heavy teams that want repo-owned agent memory running locally, with no hosted dependency and no per-seat bill.
What this tier adds
Starting tier — free CLI with Git refs and notes storage, intent records, agent context, local hub and export surfaces, and agent workflow docs.
Team Cloud
Planned
Ideal for
Teams reviewing agent-generated PRs who want related prior decisions and open risks surfaced at review time rather than in a repo-only workflow.
What this tier adds
Adds hosted collaboration on top of the free core: PR intent summaries, related prior decisions at review time, open risks and anti-patterns flags, team search, and review guardrails. Published as Planned.
Enterprise
Planned
Ideal for
Organizations that need self-hosting, policy control and audit workflows tied into existing engineering systems, including internal coding agents.
What this tier adds
Adds self-hosted or dedicated deployment, SCM and CI integration, policy controls, audit exports, and support for internal coding agents. Published as Planned.
Where the pricing makes sense
The company stage and team size where Mainline's pricing actually pencils out — and where peers do it cheaper.
The Open Source tier is $0/mo and covers the CLI, Git refs and notes storage, intent records, local hub and export surfaces, and agent workflow docs — cheaper than any hosted agent-memory or AI PR-review subscription, and the right starting point for solo builders and small teams. Team Cloud and Enterprise are published as Planned with no prices, so budgets for hosted collaboration, policy controls or audit exports can't be planned from the pricing page yet. Compare against hosted memory
Setup time & first value
How long it actually takes to get something useful out of Mainline — broken out by persona, not the marketing-page minute.
Open-source CLI: one install script plus mainline init, roughly 10-15 minutes to a working repo with agent guidance installed, and mainline doctor --setup confirms the build. Per-agent setup follows the published Codex, Claude Code, Cursor, GitHub Copilot and Windsurf docs, so allow an extra 10-20 minutes per agent workflow. First useful payoff arrives after the repo accumulates sealed intents,
Switching to or from Mainline
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From PR descriptions as your decision log: seal the reasoning behind recent merged work into intents so the history is fetchable rather than buried in closed PRs.
- →From code comments as your constraint record: move the constraints that currently sit in scattered comments into sealed module-level intents.
- →From a hosted agent-memory service: export the decisions that still matter, seal them into your Git repo, and let fetch, branch and merge carry them instead.
- →From a fresh repo with no intent history: run mainline init --actor-name and let agents start sealing from the next non-trivial change onward.
- ↗To a hosted agent-memory database: export intent records from Git refs and notes and import the decisions you want to keep searchable in the hosted service.
- ↗To PR descriptions and comments only: seal nothing further and rely on merged PRs, accepting that prior intent stays in Git refs rather than a query surface.
- ↗To an AI PR-review tool: keep the code and drop the intent layer, then rebuild review context from diffs plus whatever the new tool ingests.
- ↗To plain Git without agent memory: nothing to migrate out — intent records are refs and notes inside your existing repo, so removing Mainline leaves the code history intact.
Integrations
Resources & Guides
- Documentationmainline.sh
Docs · Mainline
Full product docs from mainline.sh
- Documentationmainline.sh
Codex · Mainline
Full product docs from mainline.sh
- Documentationmainline.sh
Claude Code · Mainline
Full product docs from mainline.sh
- Documentationmainline.sh
Cursor · Mainline
Full product docs from mainline.sh
- Documentationmainline.sh
Github Copilot · Mainline
Full product docs from mainline.sh
- Documentationmainline.sh
Windsurf · Mainline
Full product docs from mainline.sh
- Resourcemainline.sh
Spec · Mainline
Helpful link from mainline.sh
- Resourcemainline.sh
Eval · Mainline
Helpful link from mainline.sh
- Resourcemainline.sh
Glossary · Mainline
Helpful link from mainline.sh
- Resourcemainline.sh
Install · Mainline
Helpful link from mainline.sh
Tutorials & Learning
YouTube returned 6 videos for “Mainline”, and we withheld 6: 6 could not be judged, because “Mainline” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Mainline.
Official links
Tools that pair well with Mainline
Common stack mates teams adopt alongside Mainline, with the specific reason each pairing earns its keep.
Windsurf
Devin Desktop (formerly Windsurf) is an agent-native IDE for running fleets of local and cloud coding agents from one Sessions board.
Kiro
Kiro turns prompts into specs, validates them, then ships with parallel AI coding agents
Warp
Warp Factories runs fleets of cloud coding agents across your SDLC, defined in code as factory.yaml.
Featured Head-to-Head Comparisons
Mainline vs Spider Cloud
Spider Cloud and Mainline serve completely different needs. Spider Cloud is a web scraping API for feeding real-time data to AI agents and RAG pipelines, while Mainline is a Git-native memory system for coding agents to preserve intent and decisions alongside code. Choose Spider Cloud if you need structured web data for LLM context; choose Mainline if you manage multiple coding agents and want to avoid repeated mistakes by storing engineering intent in your repo.
Mainline vs Voyage Ai
Choose Voyage AI if you need high‑accuracy, domain‑specific embedding and reranking for enterprise RAG, especially on finance/legal documents with long‑context needs. Choose Mainline if you lead an AI‑heavy engineering team that wants to preserve developer intent inside Git so coding agents avoid repeated dead ends and logic conflicts. They solve fundamentally different problems: Voyage AI optimizes retrieval accuracy; Mainline optimizes agent reasoning and collaboration.
Mainline vs Temporal Ai
Choose Temporal if you need to orchestrate AI agents or multi-step workflows that must survive failures without losing state—it's built for durability at scale. Choose Mainline if your biggest pain point is coding agents forgetting context or decisions; Mainline embeds intent directly into Git, making it a lightweight fit for agent-heavy teams that already live in Git. They solve different problems: Temporal is a runtime platform, Mainline is a memory layer.
Mainline vs Shipixen
If you run coding agents and need shared intent memory inside Git, Mainline is a must-add open-source tool. If you need a beautiful, deploy-ready Next.js landing page in minutes, Shipixen's one-time purchase saves tons of boilerplate setup. They solve completely different problems — choose based on whether you're improving agent workflows or shipping marketing sites.
Alternatives to Mainline
View all
Frequently Asked Questions
Used Mainline? Help shape our editorial sentiment research.