Wie ich Scion in Entwicklungs-Workflows mit Coding-Agenten einsetze, was sich gegenüber Git ändert und was man selbst dazubauen muss.
Ein Coding-Agent kommt mit Git gut zurecht. Bei mehreren Agenten, die parallel an derselben Codebasis arbeiten, sieht es anders aus. Jeder braucht einen eigenen Klon oder Worktree, einen Branch, einen Push und einen Pull Request. Der Ablauf stammt aus einer Zeit, in der ein Mensch an einer Aufgabe saß und nebenbei auch offline arbeiten wollte.
Agenten brauchen davon wenig. Sie sind immer online, bearbeiten eine eng umrissene Aufgabe und müssen selten das ganze Repository sehen.
Deshalb verwende ich für Agenten-Workflows Scion. Das ist ein Versionssystem für Clients, die immer online sind: Historie und teure Operationen liegen auf dem Server, und lokal landet nur, was eine Aufgabe tatsächlich braucht.
In diesem Artikel zeige ich, wie der Ablauf bei mir aussieht, wo er sich von Git unterscheidet und welche Teile Scion nicht mitbringt. Wichtig vorab: Die Aufgabenteilung und die Freigaberegeln sind mein eigener Prozess. Scion schreibt davon nichts vor.
Was Scion ist
Wenn ich hier von Scion spreche, meine ich meinen Fork ArekCzarnik/scion. Er basiert auf dem Open-Source-Projekt CarterT27/scion, geschrieben in Rust unter Apache-2.0-Lizenz.
Die Idee stammt von Anthropic. In einem Artikel vom Oktober 2026 beschreibt das Unternehmen sein internes System gleichen Namens.
Ich nutze Scion nicht nur, sondern entwickle auch daran mit. In meinem Fork arbeite ich gerade an einer Integration mit SPIRE, damit sich Agenten sauber authentifizieren können. Mehr dazu am Ende des Artikels.
Zwei Dinge unterscheiden Scion vor allem von Git:
Der Server rechnet. Commits, Merges, Rebases, Historie und Blame laufen serverseitig. Ein Job, der nur einen Diff oder das Log braucht, fragt die API und kommt ohne lokale Arbeitskopie aus.
Der Client lädt nur, was er braucht. Ein Sparse Checkout holt einzelne Pfade. Für einen Agenten, der eine Aufgabe in einem Service erledigt, ist das meist genug.
Die Arbeitseinheit heißt Changeset. Ein Changeset entsteht direkt auf dem Server und ist sofort für alle sichtbar. Einen Push gibt es nicht.
Mein Ablauf in vier Schritten
Jede Aufgabe bekommt einen eigenen Workspace, damit parallele Arbeiten getrennt bleiben.
- Auftrag: Ein Mensch beschreibt Ziel, Schnittstellen und Akzeptanzkriterien.
- Umsetzung: Der Agent lädt die benötigten Dateien und erstellt ein Changeset.
- Review: Ein separater Review-Dienst zeigt Diff, Tests und Diskussion.
- Integration: Nach der Freigabe folgen
land, Integrationstests und die Deployment-Prüfung.
Nehmen wir an, eine API bekommt das neue Feld externalId. Der Agent arbeitet
dann ungefähr so:
scion login
scion checkout main /tmp/external-id --sparse services/api
# Dateien ändern, lokal testen
scion -C /tmp/external-id diff
scion -C /tmp/external-id commit -m "Add externalId to API"
Damit ist die Arbeit des Agenten erledigt. Das Changeset liegt auf dem Server,
in main ist es aber noch nicht. Das passiert erst nach dem Review mit diesem
Befehl:
scion -C /tmp/external-id land --ref main
Diese Trennung ist für Agenten-Workflows der wichtigste Punkt: Der Agent darf speichern und teilen, so viel er will, und integriert wird trotzdem nur, was freigegeben ist.
Was sich gegenüber Git ändert
Git kann all das auch, und viele Agenten arbeiten gut mit Branches und Pull Requests. Der Unterschied liegt darin, welche Schritte wegfallen und wo die Arbeit stattfindet.
| Aufgabe | Git | Scion |
|---|---|---|
| Arbeit beginnen | clone, switch -c |
checkout, optional --sparse |
| Stand speichern | add, commit |
commit auf dem Server |
| Arbeit teilen | push |
Changeset-ID weitergeben |
main aktualisieren |
Merge über PR oder MR | land --ref main |
| Werkzeuge anbinden | Git-CLI und Forge-API | Scion-CLI und gRPC-API |
Die Zeilen sind sinngemäß gemeint, die Befehle lassen sich nicht eins zu eins austauschen. Editor und lokale Tests bleiben gleich. Alles, was das Git-Protokoll spricht, funktioniert aber nicht mehr, denn Scion ist damit nicht kompatibel. Das betrifft CI-Anbindungen, Bots und interne Skripte.
Für Agenten ist die CLI angenehm: Jeder Befehl unterstützt --json mit
versionierten Schemas, und Fehlercodes sind klar definiert. Ein Agent muss also
keine Textausgaben parsen.
Drei Agenten, eine API-Änderung
Beim Feld externalId teile ich die Arbeit so auf:
| Wer | Aufgabe | Ergebnis |
|---|---|---|
| Entwicklerin | Vertrag und Akzeptanzkriterien festlegen | eindeutiger Auftrag |
| Agent A | API und Schema erweitern | Changeset A |
| Agent B | Vertrags- und Integrationstests schreiben | Changeset B, abhängig von A |
| Agent C | Nutzungsbeispiel dokumentieren | Changeset C |
| Reviewer | Verhalten und Auswirkungen prüfen | Freigabe oder Korrekturauftrag |
Die Aufteilung funktioniert genauso mit Git und drei Branches. Scion macht sie leichter, entscheidet aber nichts: Jemand muss sehen, dass B von A abhängt, und die Reihenfolge festlegen oder die Änderungen als Stack aufbauen.
Review und Freigabe muss man selbst bauen
Das ist der größte Preis, den man für Scion zahlt. Ein Pull Request auf GitHub oder ein Merge Request auf GitLab bündelt vieles an einem Ort: Diff, Kommentare, Änderungswünsche, Freigaberegeln und den Merge-Button.
Scion enthält nichts davon. Review, CI und Code-Suche liegen außerhalb des Projekts, und Land-Policies sind in Version 1 nur als Erweiterung vorgesehen. Anthropic nutzt dafür ein eigenes Werkzeug namens Antique, das nicht öffentlich ist.
| Aspekt | Git mit Hosting-Plattform | Scion |
|---|---|---|
| Review-Objekt | PR/MR mit Branch und Commits | externer Review zu Changesets |
| Diskussion | Kommentare und Änderungswünsche | muss der Review-Dienst verwalten |
| Neue Revision | weitere Commits oder Rebase | ChangeId bleibt bei amend und Rebase |
| Freigabe | Regeln der Plattform | eigene Anbindung nötig |
| Integration | Merge oder Squash nach Regeln | land integriert den Stack |
Die ChangeId ist das einzige Review-Konzept, das Scion selbst mitbringt. Sie
bleibt über alle Revisionen einer Änderung gleich, sodass ein Review-Tool
erkennt, dass Revision 3 dieselbe Änderung ist wie Revision 1.
Genau darin steckt eine Falle. Hängt die Freigabe an der ChangeId, kann ein Agent
nach dem Approval per amend etwas anderes hochladen, und die Freigabe gilt
scheinbar weiter. Sie muss deshalb an die konkrete Revision gebunden sein.
Daraus ergeben sich meine Regeln:
Vor dem Landing
- Auftrag und Diff nachvollziehen
- Tests an eine konkrete Revision binden
- Reviewer bestätigt genau diese Revision
- Nur ein Integrationsdienst darf
mainändern
Für den letzten Punkt gibt es eine Grundlage, denn Scion kennt Rechte auf Pfade und Refs.
Nach dem Landing
- Gemeinsamen Stand testen
- Fehler beheben oder die Änderung zurücknehmen
- Deployment separat freigeben
- Neue Revisionen erneut prüfen
Tests nach dem Landing braucht es, weil land die Änderung auf den aktuellen
Stand von main rebased. Getestet wurde vorher also unter Umständen ein etwas
anderer Stand als der, der am Ende integriert wird.
Wenn mehrere Agenten parallel arbeiten
land kommt ohne globale Sperre aus. Vereinfacht liest der Server den aktuellen
Stand von main, rebased die Änderung darauf und setzt main nur dann um, wenn
sich der Stand seitdem nicht verändert hat. Ist jemand schneller gewesen, beginnt
der Versuch von vorn.
Das spart das Warten in einer Schlange. Ob das Ergebnis funktioniert, ist eine andere Frage. Die Spezifikation zieht die Grenze sehr klar:
"Scion guarantees textual merge correctness only."
Was das heißt, zeigen vier typische Fälle:
| Fall | Beispiel | Reaktion |
|---|---|---|
| Unabhängige Änderungen | A ändert die API, C die Doku | Server kann beide integrieren |
| Textkonflikt | A und B ändern denselben Bereich | Mensch oder Agent löst den Konflikt |
| Fachlicher Konflikt | API liefert eine Zahl, Client erwartet Text | Vertrags- und Integrationstest |
| Abhängige Änderungen | Test B braucht API-Änderung A | Reihenfolge oder Stack planen |
Der dritte Fall ist der gefährliche. Agent A liefert externalId als Zahl, ein
anderer Agent baut parallel einen Client, der Text erwartet. Beide ändern
verschiedene Dateien, der Merge läuft sauber durch, und main ist trotzdem
kaputt. Das kann mit Git genauso passieren, und mit jedem weiteren parallelen
Agenten wird es wahrscheinlicher.
Darum plane ich Abhängigkeiten vorab ein und lasse die Agenten gegen einen festgelegten Vertrag arbeiten. Vertrags- und Integrationstests fangen ab, was der Merge nicht sehen kann.
Bei sehr hohem Tempo reicht auch das Testen vor dem Merge nicht mehr. Anthropic setzt nach eigenen Angaben auf automatisierte Tests nach dem Merge und vor dem Deployment, weil während eines Testlaufs Hunderte oder Tausende Änderungen landen können. Bei einer Handvoll Agenten kann man weiter vor dem Merge testen.
Was bei den Menschen bleibt
Diese Aufteilung gilt für mich unabhängig vom Versionssystem:
| Agenten übernehmen | Menschen verantworten |
|---|---|
| kleine Aufgaben implementieren | Ziele und Systemgrenzen |
| Tests und Dokumentation ergänzen | Verträge und Akzeptanzkriterien |
| Review-Kommentare bearbeiten | Risiken und Review-Entscheidung |
| Konfliktlösungen vorschlagen | Produktverhalten und Freigabe |
Je mehr Agenten parallel arbeiten, desto wichtiger werden kleine Änderungen, klare Schnittstellen und Aufträge, deren Ergebnis man überprüfen kann. Der Auftrag ist in diesem Setup das wichtigste Arbeitsmittel.
Anthropic beschreibt eine ähnliche Verschiebung: Das Scion-Team prüft dort weiterhin jede Änderung, achtet aber auf die Absicht dahinter und liest nicht mehr jede Zeile.
Für wen sich das lohnt
Scion ist kein Git-Ersatz für jedes Projekt. Anthropic schreibt selbst über das eigene System:
"Scion is by no means a suitable replacement for git for general use."
Gemeint sind dort vor allem riesige Monorepos mit Zehntausenden Entwicklern oder Schwärmen schreibender Agenten. Wer ein normales Repository mit ein oder zwei Agenten hat, fährt mit Git und Worktrees meist einfacher.
Vor dem Einstieg sollte man die Voraussetzungen kennen:
- einen eigenen Server mit CockroachDB und S3-kompatiblem Speicher
- Linux oder macOS, denn Windows-Clients sind nicht vorgesehen
- eine dauerhafte Verbindung zum Server, einen Offline-Betrieb gibt es nicht
- einen Git-Import nur in eine Richtung, ohne Rücksynchronisation
- eine eigene Anbindung von Review und CI
Dazu kommt der Reifegrad. Die README sagt selbst, dass Durchsatz und Ausfallsicherheit auf Anthropics Niveau nicht belegt sind. Die veröffentlichten Benchmarks stammen von einzelnen Clients auf einem lokalen Rechner, und je nach Szenario liegt mal Scion, mal Git vorn. Für ein produktives Repository würde ich das nicht ungeprüft übernehmen.
Wer es selbst ausprobieren will, sollte klein anfangen:
- Eine Wegwerfkopie eines Repositorys importieren.
- Zwei Agenten und einen Reviewer einsetzen.
- Eine API-Änderung mit eingebautem Konfliktfall bearbeiten.
- Denselben Auftrag parallel mit Git umsetzen.
- Zeit bis zur freigegebenen Änderung, Review-Aufwand und Fehlerquote vergleichen.
Dabei lohnt es sich festzuhalten, wie viel Zeit in die Eigenbauten für Review und CI fließt. Bei kleinen Teams dürfte das der größte Posten sein.
Auch ohne Umstieg bleibt etwas übrig: Eigene Workspaces pro Aufgabe, klare Verträge, Sparse Checkouts und Tests nach dem Merge funktionieren ebenso mit Git.
Woran ich gerade arbeite: eine Identität pro Agent
Im Agenten-Workflow fällt eine Lücke besonders auf. Ohne weitere
Maßnahmen teilen sich alle Agenten einen Service-Principal wie service:agent
und ein langlebiges Secret. Das hat drei Folgen:
- Ein geleaktes Secret gilt, bis jemand es rotiert, und die Rotation betrifft jeden Agenten.
- Alle Agenten haben dieselben Rechte.
- In der Historie steht
service:agentund nicht, welcher Agent gehandelt hat.
Deshalb baue ich in meinem Fork eine Anbindung an SPIRE, eine Implementierung des SPIFFE-Standards für Workload-Identitäten. Ein Agent bekommt von SPIRE ein kurzlebiges Token und tauscht es bei Scion gegen ein ebenfalls kurzlebiges Scion-Token. Ein gemeinsames Secret braucht er dafür nicht mehr. Menschen melden sich weiter über GitHub an.
Für den Workflow aus diesem Artikel ist das nützlich, weil jeder Agent eine
eigene Identität bekommt, die sich in den Zugriffsregeln benennen lässt. Agent A
darf dann zum Beispiel nur in seinem Service schreiben, und nur der
Integrationsdienst darf main ändern. Im Log steht außerdem, welcher Agent was
getan hat.
Wie das im Detail funktioniert, zeige ich im nächsten Artikel.
Quellen
- ArekCzarnik/scion: README
- ArekCzarnik/scion: SPIFFE Workload Identity
- ArekCzarnik/scion: Spezifikation
- ArekCzarnik/scion: Merge-Verhalten
- CarterT27/scion: Ursprungsprojekt
- Anthropic: Redesigning source control at Anthropic
- Pro Git: Contributing to a Project
- GitHub Docs: Pull request reviews
Stand: 2. November 2026. Die technischen Angaben zu Scion stammen aus der Projektdokumentation. Der beschriebene Ablauf ist mein eigener Prozess.