PermaShip
PermaShip runs an autonomous engineering department where Nexus, a single governing agent, decides which code changes ship.
The governance gate is what makes PermaShip worth a look. Nexus is the single entity allowed to create a ticket, which is a structurally different answer to "what stops an autonomous agent from touching my main branch" than a review bot bolted onto a PR — and open-sourcing Nexus in March 2026 means you can read the judgment layer before you trust it. Compute pricing is the tension: a small fix or test runs 1–3 Compute, but build-from-scratch and large refactors run 15+ per ticket, so a heavy refactor month chews through Starter's 400 Compute fast. Compare against review-focused tools like CodeRabbit (cheaper, narrower, PR-scoped) and Sourcegraph's issue-to-fix work.
Verified 3d ago · liveness 57/100 · cite: rightaichoice.com/tools/permaship
- Startups that want senior-engineer output without adding headcount
- Scaling teams whose velocity is lost to coordination and sprint capacity fights
- Dev shops and agencies running autonomous work across a portfolio of repos
- Teams that want continuous security patching, test coverage, and tech-debt cleanup
- Teams whose policy requires human line-by-line review of every merge
- Organizations where an AI-created ticket can't be reconciled with existing compliance process
- Repos with thin or unreliable CI, where an unreviewed Nexus-approved PR is a real risk
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 PermaShip if your policy requires a human to review every merge line by line, or if your repo's CI is too thin for an autonomous agent to open PRs against safely.
Compute is consumed per ticket by complexity — build-from-scratch and large refactor work runs 15+ Compute per ticket, so a month of heavy refactors can exhaust the $20/mo Starter's 400 Compute well before the month ends
Starter at $20/mo fits a solo dev or two-person startup doing small fixes, tests, and security patches — 400 Compute with 1 concurrent job and 30-day retention. Team at $200/mo fits a scaling product team that needs 5 concurrent jobs, Custom Docker, and 90-day retention. Scale at $2,000/mo fits a dev shop running 20 concurrent jobs across a portfolio. Against review-only tools like CodeRabbit, PermaShip is the pricier option because it writes and ships code, not just comments on it.
In short
PermaShip — PermaShip runs an autonomous engineering department where Nexus, a single governing agent, decides which code changes ship. Best for Startups that want senior-engineer output without adding headcount, Scaling teams whose velocity is lost to coordination and sprint capacity fights, Dev shops and agencies running autonomous work across a portfolio of repos. Plans from $20/mo.
What's new in PermaShip
Checked 4 days agoAcross the latest 3 updates: 3 news mentions.
We Open Sourced Nexus: The Judgment Layer for Multi-Agent AI Systems
PermaShip open-sourced Nexus, the judgment layer that governs its multi-agent AI systems, adding transparency and community trust to the core approval mechanism.
PermaShip Separates Judgment from Execution in Autonomous Engineering
Explains why PermaShip splits judgment (Nexus, which approves proposals and creates tickets) from execution (the domain-specialized agents that find and perform the work).
Sprint Planning Is Already Dead. Most Teams Just Haven't Buried It Yet
Argues sprint planning is obsolete once the bottleneck shifts from human capacity to AI capacity, which is the premise behind PermaShip's always-running agent roster.
Viability Score
How well maintained and how widely used is PermaShip? 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
- Nexus governance layer configured with your engineering philosophy and risk tolerance
- Only Nexus can create a ticket, so nothing ships without clearing its review
- Supervised mode: you approve each proposal before it ships
- Autonomous mode: Nexus acts independently inside your guardrails
- Continuous repo scanning even when the work queue is empty
- Autonomous bug detection that opens fix PRs before bugs hit production
- Security patching for vulnerable dependencies and configuration issues
- Automated test coverage written for uncovered code paths
- Code quality work across tech debt, dead code, and performance
- Specialized agents for security, reliability, performance, cost, CI health, frontend quality, and product alignment
- Feature development and multi-file refactors from approved tickets
- Compute budget tracked per ticket by complexity (1-3 / 5-15 / 15+ Compute)
- Concurrent job limits of 1, 5, or 20 depending on plan
- Custom Docker runner environments on Team and Scale
- GitHub repository connection with 5-15 or unlimited integrations by tier
About PermaShip
PermaShip is an autonomous engineering platform that runs a roster of domain-specialized agents continuously across your repositories — security, reliability, performance, cost, test coverage, CI health, frontend quality, and product alignment. The agents don't wait for prompts or sprint tickets: they find work and submit proposals to Nexus, the executive agent configured with your engineering philosophy, principles, and risk tolerance. Only Nexus can create a ticket, so nothing moves without clearing its review. You choose the autonomy level — supervised mode has you approving each proposal, autonomous mode lets Nexus act independently inside your guardrails. When the queue is empty the agents keep scanning, so latent bugs, vulnerable dependencies, missing tests, tech debt, and dead code still surface as fix PRs or new tests. It is built for three groups: startups that want senior-engineer output without hiring, scaling teams losing velocity to coordination overhead, and dev shops running a portfolio of repos where SOW work crowds out the backlog. Pricing is per month on execution rather than headcount — Starter at $20/mo (400 Compute, up to 100 tickets/mo), Team at $200/mo (4,000 Compute, up to 1,000 tickets/mo), and Scale at $2,000/mo (40,000 Compute, up to 10,000 tickets/mo). In March 2026 PermaShip open-sourced Nexus, the judgment layer itself, which separates approval from execution and makes the governance mechanism inspectable rather than a black box.
Behind the Verdict
PermaShip's core claim is that judgment and execution should be separate layers, and it is the cleanest implementation of that idea in the autonomous coding space right now. The execution layer is a roster of domain-specialized agents — security, reliability, performance, cost, test coverage, CI health, frontend quality, product alignment — that scan repos continuously rather than waiting for a prompt. The judgment layer is Nexus, configured with your engineering philosophy and risk tolerance, and it holds a hard monopoly: only Nexus can create a ticket. That single constraint is what makes autonomous mode defensible. Most autonomous-agent products ask you to trust the agent that writes the code to also decide whether the code should be written. PermaShip splits those roles, and in March 2026 it open-sourced Nexus so the approval logic is inspectable rather than asserted. Where it fits: small teams that need senior-engineer output without the headcount. The homepage case study is concrete — a CTO connected a main repo on a Friday and had 14 PRs ready Monday morning (dependency updates, a missed failing test, two security flags), approving 11 before standup. Dev shops and agencies running a portfolio of repos get the most obvious leverage, because the work that never makes it into an SOW is exactly the work an always-on scanner finds. Where it doesn't: teams whose policy requires human line-by-line review of every merge, organizations where an AI-created ticket can't be reconciled with an existing compliance process, and repos with thin or unreliable CI, where a Nexus-approved PR is a real risk. Solo developers on a tight budget should be careful — build-from-scratch work at 15+ Compute drains the $20/mo Starter's 400 Compute quickly, and that is fine for a month of small fixes but not for a rewrite. Pricing is genuinely execution-shaped rather than seat-shaped: unlimited projects and unlimited seats on every tier, a monthly Compute budget, and per-ticket consumption of 1–3 Compute for a small fix or test, 5–15 for a feature or improvement, and 15+ for build-from-scratch or large refactors. The tier ladder buys throughput more than features — concurrent jobs go 1 → 5 → 20, retention 30 → 90 → 365 days, integrations 5 → 15 → unlimited, runner memory 4 → 8 → 16 GB, and Custom Docker starts at Team. Nexus governance and supervised/autonomous mode are on all plans, including Starter. The honest gaps: the /docs page says guides, API references, and integration docs are still being written, so expect to learn largely by doing. The publicly documented integration surface in this scrape is GitHub, and the integrations page wasn't reached on this run, so treat that as the confirmed floor rather than a ceiling. Full autonomy is a cultural decision as much as a technical one — the mechanism is sounder than most, but you are still deciding how much of your main branch to hand an agent.
Researching PermaShip? 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 PermaShip actually fits — and what changes day-one when you adopt it.
Connect the main GitHub repo on a Friday and let the agent roster scan in supervised mode over the weekend. Security and reliability agents flag vulnerable dependencies and a missed failing test and submit proposals; Nexus reviews each against your risk posture and creates the tickets.
Outcome: Monday morning a batch of PRs is waiting for review — dependency updates, test fixes, and security flags — and you approve the ones you want before standup, which is the pattern Voltaire's CTO described after connecting a main repo over a weekend.
Run an autonomous improvement pipeline across the portfolio in autonomous mode, with Nexus configured to the shop's engineering philosophy so client-specific risk tolerance carries through. Agents keep scanning when the SOW queue is empty and turn latent bugs and tech debt into tickets.
Outcome: The backlog work that never made it into an SOW still gets done, and the shop delivers more per engagement without adding engineers or hours to the contract.
Keep Nexus in supervised mode for a first month to calibrate what it approves, then switch to autonomous mode inside guardrails for routine security patching, test coverage, and dead-code removal while humans keep sprint capacity for product work.
Outcome: Coordination overhead stops competing with output — improvements land continuously between sprints rather than being traded off inside them.
Use Cases
- Open fix PRs for latent bugs before they reach production
- Scan repositories for vulnerable dependencies and apply patches automatically
- Write missing tests for uncovered code paths across the codebase
- Reduce tech debt and dead code continuously without manual effort
- Build features from scratch or refactor multi-file modules on demand
- Run a governed autonomous improvement pipeline across multiple repositories
- Give a dev shop an always-on engineering layer across client engagements
Models Under the Hood
as of 2026-10-18
Limitations
- Documentation is not finished — the /docs page states guides, API references, and integration docs are still being written, so expect to learn largely by doing.
- Compute-based pricing is transparent in structure but variable in total: simple fixes and tests run 1–3 Compute, features and improvements 5–15, and build-from-scratch or large refactors 15+, so heavy refactor months can push you up a tier.
- Full autonomy depends on how much you trust Nexus's judgment, which is a cultural decision as much as a technical one.
- The publicly documented integration surface in this scrape is GitHub, and the integrations page was not reached this run.
as of 2026-10-15
Verification history
We have re-verified PermaShip 8 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-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — 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 8 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 PermaShip tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Starter
$20/mo
Ideal for
Solo developer or two-person startup doing small fixes, tests, and security patches on one repo
What this tier adds
Starting tier at $20/mo: 400 Compute, up to 100 tickets/mo, 1 concurrent job, 5 integrations, 4 GB runner memory, 30-day retention — Nexus governance and supervised or autonomous mode included
Team
$200/mo
Ideal for
Scaling product team of a handful of engineers that needs parallel work across more repos
What this tier adds
Adds 10x the Compute (4,000), up to 1,000 tickets/mo, 5 concurrent jobs, 15 integrations, 8 GB runner memory, 90-day retention, and Custom Docker over Starter
Scale
$2,000/mo
Ideal for
Dev shop or agency running autonomous work across a portfolio of client repositories
What this tier adds
Adds 40,000 Compute, up to 10,000 tickets/mo, 20 concurrent jobs, unlimited integrations, 16 GB runner memory, and 365-day retention over Team
Managed Engineering
Contact
Ideal for
Teams that want software shipped without managing another platform and would rather have PermaShip run it for them
What this tier adds
Contact-sales tier where a PermaShip technical lead scopes the work with you and runs PermaShip on your behalf — either a defined project or an ongoing engineering relationship
Where the pricing makes sense
The company stage and team size where PermaShip's pricing actually pencils out — and where peers do it cheaper.
Starter at $20/mo fits a solo dev or two-person startup doing small fixes, tests, and security patches — 400 Compute with 1 concurrent job and 30-day retention. Team at $200/mo fits a scaling product team that needs 5 concurrent jobs, Custom Docker, and 90-day retention. Scale at $2,000/mo fits a dev shop running 20 concurrent jobs across a portfolio. Against review-only tools like CodeRabbit, PermaShip is the pricier option because it writes and ships code, not just comments on it.
Setup time & first value
How long it actually takes to get something useful out of PermaShip — broken out by persona, not the marketing-page minute.
Startups and small teams can connect a GitHub repo and set Nexus's philosophy and risk tolerance in an afternoon; the first scan runs without further setup, and the published case study had PRs ready after a weekend. Dev shops should budget an extra day to configure multi-repo governance. Expect longer if you rely on internal docs, since the /docs page states guides and API references are still
Switching to or from PermaShip
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From manual code review alone: connect the GitHub repo, leave Nexus in supervised mode, and let proposals accumulate before you approve anything
- →From CodeRabbit: keep the PR-comment workflow for review while PermaShip's agents take over finding, fixing, and ticketing the work upstream
- →From a human-only backlog: set Nexus's philosophy and risk tolerance during onboarding so the agents' proposals match your existing engineering standards
- →From Sourcegraph issue-to-fix: point PermaShip at the same repositories and route self-directed work through the same Nexus approval flow
- ↗To CodeRabbit: if all you want is automated PR comments rather than code that gets written and shipped, a review-only tool is the cheaper fit
- ↗To a human team: replace Nexus-approved PRs with sprint tickets and a hiring plan if policy requires line-by-line human authorship
- ↗To prompt-driven code generation: move to on-demand tools if you decide always-on background scanning produces more proposals than you want to triage
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “PermaShip”, and we withheld 6: 6 could not be judged, because “PermaShip” 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 PermaShip.
Official links
Tools that pair well with PermaShip
Common stack mates teams adopt alongside PermaShip, with the specific reason each pairing earns its keep.
GPTConsole
GPTConsole runs autonomous AI agents that build web apps and turn Jira tickets into code.
Cognition AI
Cognition builds Devin, an autonomous AI software engineer that plans, codes, tests, and ships merge-ready pull requests inside your
Endor Labs
Agentic application security that governs AI coding agents and verifies reachable vulnerabilities before code ships
Featured Head-to-Head Comparisons
Permaship vs Truleo
Truleo and PermaShip serve entirely different domains—law enforcement intelligence vs. autonomous software engineering. Your choice depends solely on your role: if you're a police detective drowning in siloed data, Truleo is purpose-built; if you're a tech lead wanting to automate code fixes and features, PermaShip is the clear winner. No overlap in use cases, so pick the one that matches your industry.
Permaship vs Locus Robotics
For warehouse automation, Locus Robotics is the clear leader with proven AMRs and a RaaS model that scales without facility redesign. PermaShip belongs in a completely different domain — autonomous code engineering — and recent news about Anthropic’s rule changes and Nexus open-sourcing highlight its niche. Your choice depends entirely on whether you need to move boxes or fix bugs: Locus for physical fulfillment, PermaShip for code improvement.
Permaship vs Presto Voice
Choose Presto Voice if you operate QSR drive-thrus and need proven sales uplift with minimal disruption; choose PermaShip if you're a software team wanting continuous, governed code improvements without growing headcount. They solve entirely different problems, so your domain determines the fit.
Alternatives to PermaShip
View allGPTConsole
GPTConsole runs autonomous AI agents that build web apps and turn Jira tickets into code.
Cognition AI
Cognition builds Devin, an autonomous AI software engineer that plans, codes, tests, and ships merge-ready pull requests inside your
Endor Labs
Agentic application security that governs AI coding agents and verifies reachable vulnerabilities before code ships
Frequently Asked Questions
Best-of guides
Used PermaShip? Help shape our editorial sentiment research.