Remudero · long-running AI software engineering
Hand off the work.
Keep the judgment.
Remudero runs long-running AI software engineering as a steady loop. It plans in git, sends each task to the right model in its own isolated lane, proves every change before it merges, and comes to you only when a decision is truly yours.
THE CYCLE
One loop, running while you're away.
A durable plan starts the work. Recon reads the ground, isolated lanes build, review decides what merges, and every merge teaches the plan something. That is what sends it around again. You sit on the perimeter: any stage can step out to you.
Plan
set a bounded brief and the next decision
Work begins as a written plan in git: the scope, the acceptance criteria, and the proof each claim has to pass.
Recon
read the ground before touching it
A worker surveys the code first: what exists, what the change reaches, what could break. What it finds sharpens the brief.
Build
one change, in its own isolated lane
Every task runs in its own sandboxed worktree, on the model best suited to it. Many lanes move at once without stepping on one another.
Review
keep receipts and review context attached to the change
An independent review runs the proofs. A change that falls short gets a fix pass, and nothing merges on say-so.
Learn
merge, file the follow-ups, fold in the lesson
Merging is not the end. The plan is updated, follow-up work is filed as new tasks, and what went wrong becomes a check. That is what sends the loop around again.
You
pause when permission or judgment is required and name the handoff
Any stage can step out to you when a decision is yours. The lane pauses and says exactly what it needs; everything else keeps moving.
WHAT'S DIFFERENT
Built for work that runs for weeks, not minutes.
The brief outlives the session
Plans, decisions, and open questions live in git, not in a chat window. A worker can stop mid-task and the next one picks up the same thread.
Every claim carries a proof
Acceptance criteria are executable. A proof has to fail on the old code and pass on the new, so it cannot be met by accident — and the evidence stays attached to the change.
The bar only rises
Quality thresholds ratchet. Coverage and checks can tighten over time; nothing is allowed to quietly loosen them to get a change through.
Mistakes become guardrails
When something goes wrong, the lesson is written down. When a lesson keeps mattering, it becomes a check that refuses the mistake outright.
The right model for each job
Recon, build, and review are different workers, and each task is routed to the model best suited to it. The workers change with the task; the brief stays the same.
People decide the boundary
Judgment, permissions, and credentials stay with a person. The system asks rarely, batches what it needs, and brings options with a recommendation.
THE PROOF OF THE IDEA
Remudero is built by Remudero.
Since July 2026 the loop has planned, built, reviewed, and merged its own changes, unattended, while a person ratifies the decisions that are theirs to make. The system that keeps your work together is the one that keeps its own.
- Ships its own changes
- Recovers from its own crashes
- Every merge leaves a receipt
THE BOUNDARY
Autonomy, with a perimeter.
A private console can carry operational detail for the one person who operates it. This page does not expose daemon state or host credentials.
Isolated lanes
Every worker runs sandboxed in its own worktree, with scoped permissions and a hard floor of commands it will refuse.
Credentials stay put
No daemon, GitHub, or host credential ever reaches a browser. The public site holds none of them.
A record you can audit
Plans, reviews, and decisions are ordinary git history: readable, diffable, and yours.
QUESTIONS
The short answers, plainly.
What is Remudero?
Remudero is a system for long-running AI software engineering. It keeps the plan in git, runs each task in an isolated lane on the model best suited to it, proves every change before it merges, and brings a person in only when a decision is theirs to make.
How is Remudero different from an AI coding assistant?
A coding assistant works inside one session, and what it knew ends with the session. Remudero is built for work that runs for weeks: the brief lives in the repository rather than a chat window, many tasks move at once in separate lanes, and nothing merges without a proof that fails on the old code and passes on the new.
How does Remudero check that AI-written code is correct?
Every task carries acceptance criteria written as checks a machine can run. An independent review runs them against the change, a change that falls short gets a fix pass, and quality thresholds can only tighten over time, never quietly loosen.
What does a person still decide?
Judgment, permissions, and credentials stay with a person. Any stage can pause when a decision is yours: the lane says exactly what it needs and brings a recommendation, while the rest of the work keeps moving.
Does Remudero learn from its mistakes?
Yes. After each merge the plan is updated and follow-up work is filed as new tasks. When something goes wrong the lesson is written down, and a lesson that keeps mattering becomes a check that refuses the mistake outright.
Is Remudero used on real software?
Remudero is built by Remudero. Since July 2026 the loop has planned, built, reviewed, and merged its own changes, while a person ratifies the decisions that are theirs to make.
Keep the work together.
A shared brief. A durable record. Human judgment.