the real riskVibe coding broke because the code went nowhere you could see.
Describing software to an AI and watching it appear is intoxicating — until you try to run a company on it. In the enterprise, vibe coding turns into a mess fast: code nobody reviewed, lives in a sandbox or a chat thread, no branch, no history, no diff. When something breaks in production the honest answer is 'we don't know what changed.' The problem was never the AI writing code. The problem was that the output never landed in the one system built to track, review and recover changes: git. Generation got cheap; accountability disappeared.
- No branch means no isolation — one bad agent run contaminates everything.
- No commit history means no audit trail and no clean rollback.
- Code that only exists inside a tool you rent is code you don't actually own.
what git-native meansBranch first, commit checkpoints, open a PR — every single time.
A git-native agent doesn't paste code into a window and call it done. It starts from a known revision and cuts an isolated branch before it touches anything. It commits meaningful checkpoints — not every keystroke — so the history reads like a story a human can follow. It reads its own diff as part of its reasoning, catching debug code and stray edits before declaring success. Then it pushes and opens a pull request for review. Git becomes the persistence layer, the audit log and the recovery mechanism at once. Nothing is merged automatically; a structure — or a human — approves the diff, or rejects it.
- Isolated branch per task: parallel agents can't step on each other.
- Conventional commits (feat/fix/chore) so the log is legible, not noise.
- Pull request as the unit of approval — a clean artifact, not a narrative summary.
- Abandon a branch and the mistake is gone; nothing leaked into main.
your repo, not oursAgents work inside YOUR GitHub, on YOUR existing AI plan.
There's a quiet but decisive distinction between agents that clone your code into a vendor's sandbox and agents that operate directly on your own repository. Git-native means the latter. The branches show up in your GitHub. The pull requests trigger your CI, your branch protections, your required reviewers, your org policies — automatically, because it's your repo. We never hold a copy of your source. You're not migrating to a walled platform and hoping to export later; you're keeping the system of record you already trust, and adding agents that respect its rules instead of routing around them.
- Real feature branches with a clear prefix so reviewers know it's agent work.
- Your existing branch protections, required checks and reviewers still apply.
- Runs on your own Claude / GPT plan — your code path never detours through us.
the method that holds it togetherThe Digital Native Method puts a Tech Lead between the model and main.
Git-native plumbing is necessary but not sufficient — a branch full of garbage is still garbage. The Digital Native Method closes the gap. A Product Owner describes the intended outcome on the live product. A Tech Lead encodes the rules once — architecture, conventions, security boundaries, your company's standards — and every agent boots inside them. Before any branch becomes a merge, deterministic gates run with zero AI judgement: lint, types, tests, secret scanning, lock-file drift. Green, or it doesn't land. 'I never read the code' stops meaning 'nobody did' and starts meaning 'a structure verified it, every time, instead of you sometimes.'
- Encode standards once; agents physically can't ship outside them.
- Pre-push gate: lint + types + tests + security run before the PR exists.
- The Tech Lead reviews the diff before the card moves to Done.
the software, not a workflow docAgentation is the software that makes git-native real.
You can write a git-native workflow on a wiki and watch your team ignore it under deadline. A method needs software to enforce it. Agentation is that software: you point at your live product, describe the change, and a per-project Lead Agent dispatches workers into isolated git worktrees, each on its own branch. They commit, the gates run, the Lead reviews the diff, and a pull request lands in your GitHub with the checks already green. The git-native discipline isn't a hope you maintain by hand — it's the rail the tool runs on.
- One worktree + branch per task — isolation by construction, not by convention.
- Workers must read your conventions and pass the gate before review.
- You watch outcomes land as reviewed PRs, not raw output to babysit.
cocorico — souverainetéFrench-built, and sovereign where it actually counts: the tooling.
Agentation is a French company, built by a French team. We're honest about sovereignty: nobody in Europe is fully sovereign over the frontier models — Claude and GPT are American. But the models are only half the story, and with raw models alone you don't ship much. The orchestration layer — the tool that branches, gates, reviews and routes everything through your repo — is exactly where European sovereignty is winnable, and it's a huge part of the value. There, we're uncompromising: hosting in the EU (Hetzner, Germany), data in the EU (Supabase), your code staying in your own GitHub, GDPR by default. Sovereign on the tools that orchestrate the models — which is most of what matters.
- Not sovereign on the models — sovereign on the orchestration around them.
- EU hosting (Hetzner / Germany), EU data (Supabase), GDPR by design.
- Your source lives in your GitHub; we never keep a copy.
FAQWhat does "git-native" mean for an AI agent?
It means the agent works inside a real repository the way a careful engineer does: it cuts an isolated branch before changing anything, commits meaningful checkpoints, reviews its own diff, then pushes and opens a pull request for approval. Git is the audit log, the isolation boundary and the recovery mechanism — so every change is traceable, reviewable and reversible, instead of vanishing into a chat window.
Do the agents commit to my own GitHub, or to a sandbox?
Your own GitHub. The branches and pull requests appear in your repository, which means your CI, your branch protections, your required reviewers and your org policies apply automatically. The alternative — agents cloning your code into a vendor sandbox — gives you a demo you can't audit and a platform you have to escape later. Git-native means you keep your system of record.
If agents open pull requests, who reviews and merges them?
Nothing merges automatically. In the Digital Native Method, deterministic gates (lint, types, tests, security, lock-file drift) run before the PR is even ready, and a Tech Lead — encoding your standards once so every agent inherits them — reviews the diff before the work is marked done. You approve the result; the structure verifies the implementation. Required human review still applies because it's your repo.
How do parallel agents avoid stepping on each other?
Each task gets its own git worktree on its own branch — a separate working directory that shares the same history. Five agents can work at once without collisions, and a bad run is contained to its branch: abandon it and the mistake disappears with nothing leaked into main. Isolation is built into the structure, not left to discipline.
Is Agentation actually sovereign if it uses Claude or GPT?
We're precise about this. No European tool is sovereign over the frontier models — those are American. But raw models alone ship very little; the orchestration layer around them is where most of the value and the sovereignty live. There Agentation is European by design: hosting in the EU (Hetzner, Germany), data in the EU (Supabase), your code staying in your own GitHub, GDPR by default. Sovereign on the tooling that orchestrates the models — which is most of what matters.
Do I need to know git to use this?
No. The git-native discipline runs underneath, the way machine code runs under a programmer. You describe outcomes on the live product; branches, commits, gates and pull requests happen automatically. The point of git-native isn't to make you operate git — it's to guarantee that everything the agents do is recorded, reviewed and reversible in the system your engineers already trust.