There are two distinct problems in autonomous engineering. Most tools solve one and ignore the other.
The first problem is execution — writing the code, running the tests, opening the PR, deploying the fix. This is the problem most AI coding tools are designed for.
The second problem is judgment — deciding what work is worth doing before anything enters the execution pipeline. This is the harder problem, and it is the one that determines whether autonomous engineering is actually useful or just expensive chaos.
PermaShip is the execution layer. Nexus is the judgment layer. They are two distinct products with a clear relationship: Nexus decides, PermaShip does.
Nexus is open source. It is the executive agent that governs a roster of nine domain-specialized agents — CISO, QA Manager, SRE, Product Manager, UX Designer, Release Engineering, FinOps, AgentOps, and VOC. Each of these agents runs continuously, identifies work worth doing, and submits proposals.
The rule is simple: only Nexus can create a ticket. Every other agent identifies work and makes its case. Nexus decides whether it is worth doing, at the right time, for the right reason.
Nexus is not a router. It evaluates proposals against your organization's strategic alignment, risk posture, and architectural constraints. When the CISO agent and the SRE agent both propose work touching the same component, Nexus synthesizes them into a single ticket rather than letting conflicting changes hit your codebase. When context changes — a freeze directive, a red pipeline, an active incident — proposals that would otherwise pass get deferred. Same proposal, different context, different outcome.
Rejection is never silent. Every decision is logged with explicit rationale. When Nexus rejects a proposal it is either a Hard Rejection — the proposal conflicts with core principles and is killed — or a Deferral — the problem is valid but the execution plan needs work, kicked back to the originating agent with specific feedback.
When patterns of rejections emerge, Nexus does not keep rejecting the same mistake. It triggers a Knowledge Base update and encodes a new Project Rule so future proposals stop making the same mistake before they reach Nexus at all.
You can run Nexus yourself. It is free, open source, and installs in one command:
npx nexus-command
Repo: https://github.com/PermaShipAI/nexus
When Nexus creates a ticket, PermaShip executes it.
PermaShip is the production-grade execution infrastructure. Every job runs in its own isolated container. Secrets are injected at runtime via vault-style architecture and never persisted to disk. No shared runtimes between jobs, no cross-tenant access, no persistent workspaces between runs.
PermaShip handles what is genuinely hard to self-host: multi-tenant architecture, secrets management at scale, audit trails and evidence bundles, approval workflows, compliance features, and the operational burden of keeping an autonomous engineering system running 24/7 without manual maintenance.
It runs in two modes. In supervised mode, Nexus surfaces pre-vetted proposals as tickets for engineer review before anything executes. In autonomous mode, Nexus creates tickets and PermaShip executes them without waiting for human approval, then briefs the team after. PermaShip runs in autonomous mode on its own codebase today.
The reason most multi-agent engineering systems fail is not that the execution is bad. It is that there is no judgment layer deciding what should be executed in the first place.
Without a judgment layer, specialized agents scanning the same codebase contradict each other. They propose conflicting changes. They optimize locally and create global problems. They are individually correct and collectively a disaster.
Nexus prevents that. PermaShip executes what passes. The result is an autonomous engineering system that produces work your team can actually trust — because it was evaluated before it ever reached them.
Get started at permaship.ai