An engineering agent that works across your whole codebase.
DevPilot reads your repository, breaks a task into concrete steps, writes the code, runs your tests, and fixes what fails. Then it hands you a Git branch to review.
For individual developers and small teams. Free tier at launch.
$ devpilot task "Add per-key rate limiting to the public /v1 API" Indexing repository 412 files · 38,204 lines · TypeScript Reading src/server.ts, src/routes/v1/*, src/config.ts, test/helpers.ts Plan ✓ 1 Add RateLimiter middleware src/middleware/rate_limit.ts ✓ 2 Register on /v1 router src/server.ts ✓ 3 Add RATE_LIMIT_WINDOW, RATE_LIMIT_MAX src/config.ts ✓ 4 Write tests test/rate_limit.test.ts Running npm test 46 passed 1 failed ✗ returns 429 after limit is exceeded expected 429, received 200 Diagnosing middleware is registered after the router mounts; requests never reach it. Fixing move app.use(rateLimit) above app.use("/v1", v1Router) Running npm test 47 passed Ready for review branch devpilot/rate-limit-v1 · 4 files changed, +186 −3
How it works
From a sentence to a reviewed branch.
DevPilot follows the same loop a careful engineer does: understand the code, plan the change, make it, then prove it works.
Index
Maps modules, call paths, conventions, and test setup so changes fit the existing code instead of fighting it.
Plan
Breaks the task into small, ordered steps tied to specific files. You can edit the plan before any code is written.
Implement
Writes the change one step at a time, keeping track of what's done so long tasks don't lose context.
Verify
Runs your test suite, reads failures, and fixes them. When everything passes, it commits to a branch for your review.
Product
Built for the parts of software work that take the longest.
Most of a feature's cost isn't typing. It's finding where things live, keeping changes consistent, and chasing down why a test broke.
Codebase understanding
Ask how something works and get an answer grounded in the actual files, with paths and line references.
Task planning
Large changes are split into reviewable steps, so you can see the approach before the code exists.
Implementation
Multi-file edits that follow your project's existing patterns, naming, and style.
Debugging
Reproduces a failure, traces it to a cause, and proposes a fix with an explanation of what went wrong.
Test generation
Writes tests for new and existing code using the framework and helpers you already have.
Git-native
Works on branches with small, well-described commits. Nothing touches your main branch without you.
Principles
You stay the engineer of record.
DevPilot is designed to make you faster, not to make decisions behind your back.
Every change is reviewable
Output is a branch with a readable diff and a summary of what changed and why.
Plans before code
You see and can edit the plan up front, so there are no surprises in the diff.
Tests are the bar
A task isn't finished until your existing test suite passes, along with any new tests.
Your code stays yours
DevPilot runs against your local checkout. Code is never used to train models.
Pricing
Simple plans for individuals and small teams.
Planned pricing at public launch. Early-access users get Pro free during the beta.
For trying DevPilot on personal projects.
- Codebase Q&A and explanations
- Limited agent tasks per month
- Single repository
- Community support
For developers using DevPilot as part of daily work.
- Higher monthly agent task limits
- Unlimited repositories
- Automatic test runs and failure repair
- Code review on any branch
- Email support from the founder
Prices in USD. Plan limits will be published before launch.
Roadmap
Where things stand.
DevPilot Labs is an independent, self-funded company founded in 2026. Here's what's built and what's next.
Core agent loop
- Repository indexing
- Task planning and execution
- Test running and failure analysis
- Git branch output
Early-access users
- CLI release to waitlist
- Editable plans before execution
- Persistent project memory
- Code review mode
Multi-agent workflows
- Specialized agents for implementation, testing, and review
- Parallel work on independent tasks
- Team workspaces
FAQ
Common questions.
Which model powers DevPilot?
DevPilot uses Anthropic's Claude models for reasoning, planning, and code generation. DevPilot handles the tooling around the model: repository indexing, task tracking, test execution, and Git.
What languages are supported?
The prototype is developed and tested mainly on TypeScript, JavaScript, and Python projects. Other languages work for Q&A and editing. Test-running support for more ecosystems is planned for the beta.
Does DevPilot push to my main branch?
No. DevPilot only commits to its own branches. Merging is always your decision.
What happens to my code?
DevPilot runs against your local checkout. Only the context needed for a task is sent to the model provider, and your code is not used to train models. See the privacy policy for details.
When can I use it?
DevPilot is in private development. Early access will open to the waitlist in small groups. Email [email protected] to request a spot.
Get early access to DevPilot.
Tell us a bit about what you're building. We read every email.