SuperPlane · October 27, 2026
Every engineer on your team now has a coding agent. But nothing happens until someone opens a session. Everyone’s setup is different.
Most agent tools today are built for one person: your laptop, your prompts, your cloud sandbox. That works great for power users. But engineering is a team sport. When everyone runs agents their own way, you end up with forty private workflows and nobody can tell what’s going on.
And the agents still need oversight. Someone has to decide if a task is ready, check that the result works, chase CI and answer review comments. That’s where the hours go. A lot of software development is routine work. We’ve turned our best engineers into water carriers for their agents.
It’s an automation problem. A software factory solves it.
Why now
The last few weeks made something obvious: agents are finding critical vulnerabilities in the software everyone depends on faster than ever.
When one of those hits a core dependency, you need to patch it, test it and deploy it. Can you do that within an hour? While you sleep? Most teams can’t move that fast, because the ticket waits until someone has time.
A software factory fixes that. The CVE lands, the work starts right away and it comes back tested and ready for someone to approve.
So today we’re launching SuperPlane 1.0. It’s an open source, model-agnostic software factory for engineering teams. It sits around your coding agents and gives the whole team one shared, repeatable path from ticket to verified, merged pull request.
What we believe
CI/CD made shipping a team habit. Factories will do the same for agents. Fifteen years ago, teams argued about whether automated testing was worth it. Now nobody ships without it. We think every engineering team will run a software factory within a few years. We’ve seen this movie before.
Most tickets aren’t ready for an agent. Throwing vague work at an agent wastes everyone’s time. SuperPlane reads your backlog, scores each task for clarity, complexity and verifiability and helps you fix the weak spots before anything runs.
“Done” needs proof. Every change comes back with evidence: passing checks, screenshots of the real UI, recordings and a note about anything it couldn’t verify. Human or agent reviewers check the proof.
The first commit is the easy part. Failing CI and review back-and-forth are where the hours go. SuperPlane loops the agent back with the evidence until the PR is ready for a person.
People make the calls only people can make. What to build, which trade-offs to accept, how much risk is fine. Everything else is the factory’s job. You decide what ships.
You should own your factory. It’s open source, it runs on your infrastructure and it works with whatever models and agents you pick.
A factory does the work that wouldn’t have happened
Over the last month, 52% of the pull requests our team merged were automated through SuperPlane. People often hear that and assume we handed off half our work. What actually happened is we got a bunch of extra work done that we’d never have gotten to.
Our factory's Velocity page compares merged pull requests automated through SuperPlane with manual work. Every workspace has this view.
Every task runs in its own cloud development environment, in parallel, while our engineers keep working on their own stuff. You can’t run ten of those on a laptop. It’s like having a second shift that never takes time away from the first one.
Built for the whole team
A software factory works when the whole team can share it, see into it and make it better.
- One shared environment. Skills, setup steps, tools and context belong to the team. When someone improves them, everyone’s next run gets better.
- One set of standards. Readiness checks and verification rules are set once for the team, so everyone works the same way. Sane defaults work out of the box. You can build your own automations that mix deterministic and agentic steps.
- Everyone can see what’s happening. One kanban board shows what’s running, what failed, what it cost and where a person is needed. The run history sticks around through retries and handoffs. The Velocity page shows how much the factory is adding.
The shared factory board shows backlog, implementation, verification and completed work in one place.
Where to start
You can use as much or as little of it as you want. The teams getting the most out of it started small:
- Small, well-defined bug fixes.
- Dependency and security updates, handled automatically.
- Small improvements nobody gets around to.
Most teams figure out pretty quickly where it fits. The standards they set up along the way carry over to bigger work.
Why us
Before SuperPlane, we spent more than ten years building developer tools at Semaphore, helping some of the world’s best engineering teams ship faster with CI/CD. We watched CI go from optional to obvious. With SuperPlane we’re bringing that same care for clear workflows, real verification and team-wide visibility to coding agents.
Petar Jerinic, Head of Engineering at Brame, said:
“I was amazed by SuperPlane’s ease of use and time to value. The confidence score functionality rocks! It asked the right questions for ambiguous tasks, and the PRs were great.”
Try it
SuperPlane is available today. Head to superplane.com, star the project on GitHub and give it a bug in your backlog.
Every engineering team will run a factory. We think it should be open and yours.
FAQ
What is SuperPlane?
SuperPlane is an open source, model-agnostic software factory for engineering teams. It sits around your coding agents and takes work from ticket to verified, merged pull request. The whole team shares the same standards and can see every run.
What is a software factory?
A software factory is a shared system that turns tickets into tested code changes. It checks whether a task is ready, runs a coding agent on it, verifies the result and loops back until the pull request is ready for a person to review.
Does SuperPlane replace engineers?
No. People decide what to build, which trade-offs to accept and how much risk is fine. SuperPlane handles the routine work around the agent. Your team sets the rules for what gets merged and who approves it.
How does SuperPlane verify agent work?
Every change comes back with evidence: passing checks, screenshots of the real UI, recordings and a note about anything it couldn’t verify. When CI fails or a reviewer leaves comments, SuperPlane sends the agent back with that evidence until the pull request is ready.
Which models does SuperPlane work with?
SuperPlane is model-agnostic. It works with models from OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen and Kimi. Teams can also connect their own model accounts and API keys.
Is SuperPlane open source? Can we self-host it?
Yes. SuperPlane is open source under the Apache 2.0 license and the code is on GitHub. The community version runs on your own infrastructure. Enterprise self-hosting is also available.
How is SuperPlane different from single-user agent tools?
Most agent tools are built for one person’s laptop and prompts. SuperPlane is built for the team. Every task runs in its own cloud development environment, so the factory can work on many tasks in parallel while your engineers keep working on their own stuff. Skills, setup, readiness checks and verification rules are shared. One board shows what’s running, what failed, what it cost and where a person is needed.
How much does SuperPlane cost?
You can start on Pay-as-you-go with no monthly fee and pay only for what you run. Starter is $20 per organization per month and Team is $50 per user per month, both plus usage. Usage covers sandbox time and model tokens. If you bring your own model account, SuperPlane adds no token markup. See pricing for details.
Where should a team start with SuperPlane?
Start small. Good first tasks are well-defined bug fixes, dependency and security updates and small improvements nobody gets around to. The standards you set up along the way carry over to bigger work.
Originally published at the SuperPlane blog.