Agenci kodowania równoległego z worktreeami Git, Conductor i Antigravity 2.0

Od obsługi terminali do wizualnego narzędzia do zarządzania

Jeśli rok 2025 był rokiem agentów AI, to 2026 wygląda na rok, w którym wiele agentów będzie pracować razem, a jeden z inżynierów Google wcześnie przewidział, że to będzie rok orkiestracji agentów. Dla tych, którzy cały czas pracują w terminalach, problemy pojawiają się szybko. Próba koordynacji zespołu równoległych podagentów tworzących małą grę z zegarem, przy użyciu okien tmux, pobierania plików z repozytorium oraz notatek na monitorze, by pamiętać, która sesja wykonuje jakie zadanie, przerodziła się w prawdziwy chaos poznawczy.

Na zdjęciu widać kilka pulpitów macOS wypełnionych terminalami agy z notatkami, co dobrze ilustruje, jak wygląda zarządzanie równoległymi przestrzeniami roboczymi agentów bez odpowiednich narzędzi.

Idea tworzenia aplikacji za pomocą narzędzia typu multi-agent pochodzi od posta z czerwca 2026 roku, który pokazał, jak jeden prompt generuje cztery równoległe agenty programistyczne i tworzy działającą aplikację w mniej niż dwie minuty. Narzędzia CLI o określonych funkcjach są doskonałe do zadań jednowątkowych, ale kilka jednoczesnych strumieni agentów, z których każdy ma własną gałąź, mechanizm checkout oraz pętlę zwrotną koordynatora, nie mieści się w prostym buforze scrollback. Dlatego następnym krokiem było przejście na aplikację desktopową Antigravity 2.0.

Aplikacja grupuje wszystko według projektu, czyli w zasadzie w folderze, i wyświetla w nim wątki, najnowsze na górze. Projekt osobisty może zawierać wątek dotyczący dodania niebieskiego przycisku logowania z ukrytym hasłem oraz inny dotyczący dodania ścieżki backendowej /checkout/, natomiast projekt służbowy zawiera wątki związane z pisaniem pliku doc/PRD.md oraz dodawaniem testów bezpieczeństwa. Wątki można archiwizować, dzięki czemu przetrwają restart, a nikt już nie potrzebuje fizycznych notatek.

Gdy już działa wizualne narzędzie, następnym pytaniem jest skalowalność. Samotna środowisko testowe i prosta gra to proste przypadki. Ta konfiguracja pozwala rozszerzyć aplikację desktopową do symulacji SRE z 12 ścieżkami, wykorzystując worktree’y w Git, orkiestrator o stylu Rails o nazwie Conductor++ oraz agent typu concierge o nazwie Agostina.

Illustracja pokazuje programistę, który próbuje kontrolować zbiór podagentów worktree’ów, trzymając w ręku panettone.

Zaproszenie, które to zapoczątkowało

Inspiracją był zwięzły opis zadania dotyczący stworzenia aplikacji do rezerwacji pokoi hotelowych przy małym zespole agentów.

Let's build a hotel room booking app [..].

First, launch the Engineering Manager agent to ... into an artifact called 'architecture.md'.

Once the design is ready, launch three agents in parallel:
1. Test Manager: Write <SPECS> to 'architecture.md'.
2. Backend Engineer: Build an API based on <SPECS> .
3. Frontend Engineer: Build a web UI based on <SPECS>  to interact with the API <details>.

[..] How to sync the 3 sub-agents [..]

Finally, spin up both components and a browser so I can test the live app.

Przy bliższym przyjrzeniu się widać, co się w nim znajduje:

1. opis żądanego produktu – w tym przypadku aplikacji do rezerwacji hoteli
2. zespół trzech podagentów
3. porządek i czas ich wzajemnej interakcji
4. to, co dzieje się na końcu, gdy system jest uruchamiany dla osoby, która nie jest tak ściśle zaangażowana w proces inspekcji
5. jedyna rzecz najważniejsza – wspólny stan pliku: wspólny plik architecture.md

Diagram pokazuje, w jaki sposób agenci w tym przykładzie ze sobą współpracują. To meta-programowanie w czystej postaci. Instrukcja nie opisuje kodu, lecz zespołu, który go napisze. A agenci komunikują się ze sobą za pomocą pliku w formacie Markdown, co oznacza, że same specyfikacje stanowią kanał komunikacji.

Lista życzeń dotycząca równoległego ustawienia posunęła się dalej: implementacja jest uruchamiana przez GitHub Issues (GHI), dzięki czemu każdy podagent otrzymuje rzeczywisty ticket.

Składniki procesu pracy

Ustawienie to składa się z kilku elementów.

• Integracja z issue’ami. Każdy podagent powinien pracować nad danym issue’em, gdy taki istnieje.
• Rails dla AI. Rozszerzenie Conductor zapewnia agentom określone „szyny”, czyli jasno określone granice. Sam issue nie zawsze dostarcza wystarczająco dużo informacji, aby agent mógł podjąć działanie, a czasami osoba ludzka zaangażowana w proces (HITL) musi odpowiedzieć na trudne pytania, co zapobiega nieprecyzyjnym implementacjom, takim jak „oczywiście miałem na myśli tylko zalogowanych użytkowników”.
• git worktree. Worktrees zapobiegają temu, by dwa lub więcej agentów niszczyły ten sam repozytorium. Gdy N agentów otwiera prośby o połączenie z odległymi gałęziami, sensowne jest również posiadanie „konserjera git”, który integruje kod z gałęzią main. Ta rola powinna być ostrożna. Podczas gdy agent X próbuje wdrożyć funkcję X, konserjer pozostaje niewzruszony i stanowi ostatnią linię obrony przed brakiem spójności, ponieważ kod może być poprawny, ale zostać wdrożony bez przeprowadzenia testów ani aktualizacji dziennika zmian, a nowe okno kontekstowe dobrze to wykrywa.

Aby móc ponownie wykorzystać całe to rozwiązanie w różnych bazach kodu, zasady i automatyzacja zostały zamknięte w otwartym oprogramowaniu typu agent skill o nazwie conductor-worktree-hitl, powszechnie nazywanym condutree. Jego podstawowe komponenty to:

• git worktree do asynchronicznego wdrażania, z jednym podagentem na każdy worktree oraz jedną ścieżką Conductor
• GitHub Issues w połączeniu z Conductorem dla określenia wyraźnych granic implementacji
• Antigravity 2.0 jako narzędzie wizualne do zarządzania procesem
• stan przechowywany na dysku, dzięki czemu kontekst agenta jest zachowywany między różnymi uruchomieniami; kompatybilne z Conductorem, ale z dodatkowym stanem opartym na plikach do łączenia zadaniami oraz eksperymentalną ramą pytań i odpowiedzi dla podagentów
• opcjonalnie plugin dostarczający umiejętność using-git-worktrees w celu automatyzacji izolacji worktree

Istnieją trzy powody, dla których umieszcza się to jako osobną umiejętność, zamiast wklejać polecenia git do poleceń koordynatora. Po pierwsze, wszystkie proste operacje konfiguracji przestrzeni roboczej, tworzenie symbolicznych powiązań oraz wykluczanie plików w git są zawarte w jednym łatwym do utrzymania skrypcie. Po drugie, poleceń koordynatora pozostaje niewiele i są one skupione na delegowaniu zadań od głównych agentów do podagentów oraz rozwiązywaniu pytań, dzięki czemu agent nie musi męczyć się z składnią git. Po trzecie, inni programiści mogą włączyć tę umiejętność do swoich repozytoriów i narzędzi, uzyskując bezkonfliktowe równoległe działanie bez konieczności przepisywania skryptów integracyjnych.

Agent wyposażony w tę umiejętność uczy się czterech rzeczy:

1. jak tworzyć niezależne drzewa robocze do wykonywania zadań równocześnie
2. zasad higieny git, a mianowicie tworzenie symbolicznych powiązań z wspólnymi folderami metadanych Conductor oraz ich wykluczanie lokalnie, aby git status pozostawał czysty
3. podwójny protokół reentrant HITL do publikowania komentarzy do problemów, odczytywania lokalnych rejestrów oraz sprawdzania odpowiedzi bez wyczerpywania kwoty API
4. sposób komitowania lokalnego oraz zapisywania potwierdzeń jako notatek Git, bez bezpośrednich wysyłek na serwer zdalny

Wersja 1.0 stanowi solidną bazę, a planowana jest wersja 2.0 z automatycznym symlinkowaniem konfiguracji oraz bardziej zaawansowanymi skryptami pomocniczymi.

To ilustracja stworzona przy użyciu AI nawiązuje do powiedzenia „zbyt wielu kucharzy w kuchni”: tłum podagentów programistycznych psuje jeden gałąź z powodu braku izolacji drzewa roboczego.

Test obciążeniowy: symulator incydentów SRE

Aby sprawdzić, jak daleko można posunąć równoległą eksploatację, model został zastosowany w rzeczywistym symulatorze automatyzacji SRE oraz zarządzania incydentami. Celem nie były proste aplikacje, lecz system wielu agentów, który audytuje środowiska chmurowe i jednocześnie koordynuje radzenie sobie z incydentami w kilku izolowanych przestrzeniach roboczych. Zanim system mógł działać bez konfliktów, trzeba było rozwiązać kilka kwestii związanych z organizacją plików w formacie git oraz ich nazywaniem.

• Zanieczyszczenie symlinkami. W konfiguracji Conductor++, każdy agent równoległy ma swoją własną przestrzeń roboczą, na przykład .worktrees/telegram_incident_creation/. Ponieważ podagenty przekazują metadane z powrotem do koordynatora, katalog główny conductor/ jest symlinkowany do każdej przestrzeni roboczej za pomocą polecenia ln -s ../../conductor conductor. Wszystko poza tym folderem różni się w zależności od przestrzeni roboczej, a ponieważ każda ścieżka znajduje się we własnej podfoldercie conductor, problemy z łączeniem plików są bardzo mało prawdopodobne.
• Koordynatorka. Główną „konserżanką” Git jest Agostina – spokojna, zorganizowana Włoszka, która funkcjonuje pod wpływem espresso i utrzymuje synchronizację pomiędzy podagentami takimi jak Mario i Luigi, nie pozwalając im na wzajemne przeszkadzanie sobie. Celowo jest Włoszką, a jej imię nieco przypomina nazwę Antigravity.
• Skryba. Poświęcony agent o imieniu Amanuense, nazwany od łacińskiego słowa oznaczającego skrybę, rejestruje tworzenie katalogów, zmiany w kodzie oraz interakcje agentów wraz z dokładnymi datami i godzinami w jednym centralnym pliku audytowym, dzięki czemu można zobaczyć, kto co zrobił, kiedy i w którym worktree’u. Został stworzony, aby sprawdzić, jak dobrze działa synchronizacja podagentów, oraz aby dostarczyć dokładnych danych czasowych i zapisów do raportowania.

Uruchamianie kilku agentów AI w jednym repozytorium wymaga ścisłej izolacji oraz sposobu komunikacji wolnego od konfliktów.

Tutaj Agostina rozwiązuje fuzje zmian od Mario i Luigi, podczas gdy trzeci, żółty podagent nadal pracuje nad swoim własnym drzewem zadań.

Zasady utrzymujące repozytorium w porządku

Większość wpływu miało kilka decyzji projektowych.

• Brak bezpośrednich wysyłek z zdalnego serwera. Jeśli wiele podagentów uruchomi naraz polecenie git push, powoduje to kolizje blokad na zdalnych referencjach i może doprowadzić do wdrożenia nieprzetestowanego kodu. Podagenty komitują zmiany tylko na lokalnych gałęziach feature/ i piszą streszczające notatki w Git. Tylko koordynator może wysyłać zmiany, pobierać gałąź walidacyjną oraz łączyć gałęzie funkcjonalne.
• Podwójny protokół pytań reentrywnych. Jedyny globalny plik questions.json powodowałby konkurencję przy zapisie, gdy podagenty zadawałyby pytania jednocześnie. Zamiast tego podagent zapisuje swoje pytanie w swojej prywatnej folderze śledzenia (conductor/tracks//metadata.json), co całkowicie eliminuje takie problemy. Pytanie jest również publikowane jako komentarz do issue na GitHubie, zawierający unikalną podpisę śledzącą. Skrypt badawczy Agostiny najpierw sprawdza, czy jakiś lokalny folder ma status awaiting_human. Jeśli nie ma takiego folderu, wywołanie API GitHuba jest całkowicie pomijane, co pozwala zaoszczędzić ponad 95 procent kwoty. Gdy na GitHubie pojawi się odpowiedź pasująca do pytania, lokalne metadane zmieniają się na answered, co budzi podagenta.
• Wspólna pamięć w stylu wiki. Zamiast wypełniać kontekst każdego podagenta całą historią projektu, wspólny katalog conductor/ pełni rolę trwałej pamięci – ustrukturyzowanego katalogu lokalnego, który agenci mogą czytać i edytować jak stronę wiki. Odzwierciedla to dobrze znany pogląd Andreja Karpathy na temat pamięci modeli językowych, a także odnosi się do powszechnego obawienia, że źle zarządzana pamięć agentów zamienia asystentów w złote rybki.
• Kaskadowe rozwiązywanie konfliktów. Gdy zakończone gałęzie funkcjonalne są łączone jedna po drugiej, może wystąpić efekt kaskadowy. Gałąź Mario łączy się bez problemów z gałęzią walidacji, natomiast u Luigiego pojawiają się konflikty. Jeśli osoba ludzka naprawi konflikt Luigiego na gałęzi walidacji, jego oryginalna gałąź funkcjonalna w drzewie pracy pozostaje w stanie konfliktu i przestarzała. Aby zapobiec temu zanikaniu, Agostina wybiera poszczególne rozwiązania lub łączy je z powrotem z gałęzią Luigiego, utrzymując izolowane drzewo pracy zgodne z zweryfikowanym kodem.
• Zamiast wysyłać zmiany bezpośrednio do main, używa się żądań pull. Wysyłanie połączonej gałęzi walidacji bezpośrednio do main omijałoby procedury sprawdzania, dlatego integracja odbywa się poprzez PR. Podagenty dokonują komitów lokalnie, Agostina pobiera zmiany, weryfikuje je i łączy lokalnie, a po przejściu testów integracyjnych wysyła zjednoczoną gałąź oraz uruchamia polecenie gh pr create --title „feat: ...“ --body „...“. Człowiek sprawdzający może następnie przejrzeć różnice i wyniki testów CI w własnym interfejsie GitHuba. Agostina zapisuje adres PR w pliku metadata.json rejestru i pokazuje aktualny stan za pomocą poleceń gh pr list oraz gh pr status.
• Zakończenie z powodu konfliktów koncepcyjnych. Dwie ścieżki mogą być logicznie niekompatybilne, na przykład gdy jedna implementuje funkcjonalność, a druga ją refaktoryzuje w niekompatybilny sposób. Jeśli Agostina to zauważy, może natychmiast zakończyć działanie jednego z konfliktujących podagentów. Anulowanie musi zostać odnotowane w zadaniu tego agenta, a zadanie to musi być zablokowane lub powiązane z zadaniem drugiego agenta, aby zachować przejrzysty ślad decyzji. Zdarzyło się to dokładnie raz.

Życiowy cykl orkiestracji

Człowiek-kierownik nigdy nie rozmawia bezpośrednio z podagentami. One działają w całkowitej izolacji w swoich drzewach roboczych, a osoba ta rozmawia jedynie z koordynatorem w dwóch momentach: podczas rozpoczynania procesu oraz przy odpowiadaniu na pytania przekazywane przez nadzorcę HITL.

Diagram przepływu przedstawia żywotny cykl agenta i podagenta w sześciu krokach:

1. Rozpoczęcie. Kierownik uruchamia proces.
2. Czytanie statusu. Agostina sprawdza aktywne problemy w GitHubie oraz stany ścieżek w Conductorze.
3. Przygotowanie. Tworzy izolowane drzewka robocze oraz uruchamia równoległe podagenty programistów.
4. Nadzór HITL. Pytania blokowane przez podagenty są kierowane do człowieka, a odpowiedzi są do nich odsyłane, co zapewnia bezpieczny i asynchroniczny obieg informacji.
5. Czyszczenie. Gdy podagenty kończą pracę i otwierają swoje PR-y, Agostina usuwa tymczasowe katalogi drzewek roboczych.
6. Łączenie z główną wersją. Integruje zmiany oraz otwiera lub łączy ostateczny PR, po czym wraca do kroku czyszczenia w celu załatwienia pozostałych zadań. Może to przerodzić się w prawdziwą walkę, ale agenci radzą sobie z łączeniem plików w Git lepiej niż ludzie.

Odpowiadanie na pytania jest nadal w fazie eksperymentalnej i wypróbowano trzy podejścia. Jednym z nich jest mostek typu Telegram sidecar, który działa jako demon w tle, wysyła pytania lub zatwierdzenia zmian w bazie danych na telefon dewelopera za pośrednictwem bota Telegrama i sprawdza obecność odpowiedzi.

Diagram pokazuje asynchroniczny przepływ w Telegramie. Jego zaletami są możliwość odpowiadania i udzielania zatwierdzeń w pierwszej kolejności na urządzeniach mobilnych, paralelizm bez konfliktów, ponieważ pytania znajdują się w katalogach przypisanych do poszczególnych ścieżek, co unika konfliktów dotyczących blokad plików, oraz ślad audytowy, gdyż każda decyzja jest przechowywana w repozytorium w formacie JSON. Najprostsze rozwiązanie, polegające na komunikacji z głównym agentem za pomocą pliku questions.json, zostało odrzucone, ponieważ nigdy nie odblokowywało się automatycznie i wymagało ręcznego uruchomienia, chociaż haki lub przyszłe wersje mogłyby to naprawić.

Przypadek studialny: dwanaście ścieżek SRE w pięciu godzinach

Środowisko testowe stanowiło aplikację internetową zbudowaną wokół rozszerzenia SRE. Wiele jej funkcji mogło być wykonywanych równolegle: ekrany interfejsu użytkownika, punkty końcowe backendu, asystent czatowy wspierany przez model językowy, bot Telegrama, narzędzia OpenTelemetry oraz odkrywanie zasobów GCP.

Proces ten wykorzystał dwanaście zaawansowanych funkcji SRE i podzielił je na ponad dwadzieścia konkretnych zadań na GitHubie. Następnie uruchomiono proces automatyczny. W ciągu około pięciu godzin, głównie w trybie bez nadzoru, pipeline Conductor++ stworzył, przetestował i połączył wszystkie te elementy z główną gałęzią. Zakres prac obejmował od konfiguracji śledzenia zdarzeń za pomocą OpenTelemetry w Cloud Run po tworzenie interaktywnych narzędzi do obsługi incydentów w Telegramie oraz rejestrów służących do zatwierdzania planowanych zmian.

Integracja i wyniki połączenia

Dzięki orkiestracji równoległych zadań każda z gałęzi funkcjonalnych została opracowana, przetestowana i zintegrowana z main.

Zdjęcie tabeli przedstawia końcową audytę stanu głównych ścieżek. Zintegrowano również osiem dodatkowych ścieżek operacyjnych, obejmujących taksonomię stanów incydentów, usuwanie i archiwizację incydentów, łączenie projektów wiki, zarządzanie stanem w wielu środowiskach, przenoszenie stanu do chmury, responsywny interfejs użytkownika wiki, łączniki do GCP w czasie rzeczywistym oraz bieżące zmiany.

Dwa tygodnie po zakończeniu procesu stan Conductor można sprawdzić za pomocą pojedynczego polecenia task-runner, które uruchamia inspektora w repozytorium i wyświetla podsumowanie przestrzeni roboczej.

$ just conductor-status
python3 conductor/bin/conductor-inspector . --open --short

🔍 Inspecting Conductor Workspace: /usr/local/google/home/ricc/git/adk-sre-benjamin
📦 Product: Initial Concept
STATUS      |  PROGRESS  | RATIO |  GHI  |   AGENT    |   CHANGED   | TRACK ID                                           |  🌳
==============================================================================================================================
NEW         | ░░░░░░░░░░ |  0/25 |  #23  |            |  💻 15days   | managed_agents_sandbox_20260616                    |
NOT_READY   | ░░░░░░░░░░ |  0/17 |  #22  |            |  💻 15days   | mcp_streamline_abilities_20260616                  |
NOT_READY   | ░░░░░░░░░░ |  0/11 |  #15  |            |  💻 15days   | migrate_tf_cb_logic_20260616                       |
NOT_READY   | ░░░░░░░░░░ |   0/9 |  #21  |            |  💻 15days   | ai_engineering_practices_20260616                  |
NOT_READY   | ░░░░░░░░░░ |   0/9 |  #19  |            |  💻 15days   | workspace_agent_installation_20260616              |
NEW         | ░░░░░░░░░░ |  0/15 |  #31  | antigravity|  🐙 16days   | disable_mock_fallback_dev_20260616                 |
==============================================================================================================================
TOTAL       |            |  0/86 |       |            |              | 0 completed, 6 open (6 total)                      | 0 🌳

Horyzont czasowy procesu

Krok po kroku przedstawiono przebieg działania, pokazując, jak koordynator, sekretarz oraz równoległe podagenty unikali wzajemnych kolizji.

Krok 1: inicjalizacja ścieżek i drzew roboczych

Na komputerze głównym rodzicielski koordynator przygotował przestrzenie robocze. Następnie interfejs CLI inspektora Conductor wylistował aktywne ścieżki i przekazał je nazwanych podagentom – jeden zajmował się salami dyskusyjnymi w Discordzie, a drugi bieżącymi mutacjami. Flaga zawierająca wszystkie ścieżki umożliwia temu samemu narzędziu wyświetlanie gałęzi oraz stanów agentów we wszystkich równoległych przestrzeniach roboczych.

./scripts/conductor-inspector /Users/ricc/git/adk-sre-benjamin --all

Poniżej znajduje się wyjście terminala zapisane podczas inicjalizacji.

================================================================================
  CONDUCTOR++ ACTIVE WORKTREES & TRACKS INSPECTION
================================================================================
[Track: telegram_incident_creation_20260603]
  Worktree: .worktrees/issue-29-telegram-wizard
  Branch:   feature/issue-29
  Agent:    pinocchio
  Status:   AWAITING_HUMAN (Question: "Verify Telegram Token config?")
  GHI URL:  https://github.com/palladius/adk-sre-benjamin/issues/29

[Track: unified_incident_lifecycle_observability_20260607]
  Worktree: .worktrees/issue-18-discord-warrooms
  Branch:   feature/issue-18
  Agent:    grazia
  Status:   RUNNING
  GHI URL:  https://github.com/palladius/adk-sre-benjamin/issues/18
================================================================================

W tym wykazie podagent zajmujący się bieżącymi mutacjami jest zablokowany i czeka na odpowiedź od HITL.

Naturalnym pytaniem jest to, czy kwestie w GitHub i ścieżki w Conductor to to samo. Są to dwa systemy, które mogą ulegać rozbieżnościom. Poproszono agenta o wykrycie takich rozbieżności pomiędzy nimi.

Zdjęcie ekranu pokazuje przegląd aktywnych drzew roboczych, gałęzi oraz przydziałów podagentów. Ujednolicenie obu systemów wymaga jedynie instrukcji skierowanej w jednym lub drugim kierunku. Jedna z opcji polega na poproszeniu Conductor o utworzenie nowej ścieżki dla każdej kwestii, zadając wszystkie niezbędne pytania po kolei. Druga opcja polega na upewnieniu się, że dla każdej ścieżki w Conductor istnieje odpowiadająca jej kwestia.

Widok szczegółowy pokazuje bieżące pytanie od HITL czekające na dane z GitHub Issues.

Krok 2: izolacja równoległych drzew roboczych

Każdy agent pracował na swojej własnej gałęzi, a scribe rejestrował dokładne zmiany w plikach oraz wydarzenia w przestrzeni roboczej bez żadnych konfliktów.

To zrzut ekranu przedstawia monitor plików worktree podczas równoczesnego rozwoju.

Narzędzie do śledzenia wątków Antigravity pokazuje trwające zadania – coś, co z pewnością zaimponowałoby oryginalnej wersji demo z jednym poleceniem i czterema podagentami.

Krok 3: pytania i kierowanie przez człowieka

Gdy agenci potrzebowali wyjaśnień, publikowali problemy, które analizował skrypt poll_ghi_questions.py. Aby umożliwić kierowanie przez człowieka w urządzeniach mobilnych, pytania były przekazywane przez mostek Telegram sidecar. Operator nie musiał siedzieć przy komputerze i odświeżać strony GitHub, ponieważ mostek wysyłał każde pytanie na telefon, umożliwiając szybne zatwierdzenia w dowolnym miejscu.

Zrzut ekranu pokazuje w praktyce pętlę zwrotną dotyczącą zatwierdzeń i diagnostyki.

Krok 4: końcowy stan zielony

Po tym, jak każda gałąź funkcjonalna przeszła weryfikację i została po kolei połączona, Agostina otworzyła prośbę o pull request, a ostateczna audytacja potwierdziła, że wszystkie dwanaście ścieżek SRE zostało połączonych z gałęzią produkcyjną. Czy wszystkie zostały w pełni przetestowane, w tym pod kątem sposobu ich wzajemnej interakcji? Nie do końca, a to temat na dalszą pracę. Narzędzie wizualizacyjne o nazwie Conductor At Scale przekształca również ogólny historial git w animację w stylu arkadowym, przy czym ścieżki Conductor eksplodują na ekranie za pomocą JavaScriptu.

Lekcje z tego procesu

Pierwszą lekcją jest utrzymywanie rozmowy z pojedynczym agentem, gdy to możliwe, oraz przekazywanie podagentom jedynie prostych, z góry określonych zadań, które nie wymagają interakcji. Dwie praktyki wspierają to podejście.

• Zminimalizuj czas oczekiwania pomiędzy agentem a człowiekiem. Polecenie /roastme to dobry sposób na przedwczesne ujawnienie trudnych pytań, dzięki czemu agent może pracować bez przeszkód, a Conductor doskonale radzi sobie z zbieraniem pytań offline. Zamiast zadawać pytanie co 5 minut na 30 sekund, odpowiadasz na wszystko w jednym 30-minutowym bloku, jeździsz na rowerze i wracasz do aplikacji już ukończonej.

Na tym zrzutku ekranu widać, jak /roastme działa wewnątrz Conductora, włączając błędy pisowni.

• Utrzymuj prostą relację pomiędzy agentem a podagentem. W branży często mówi się o skomplikowanych hierarchiach wielu agentów, ale w 2026 roku bezpieczniejszym wyborem są proste, powtarzalne zadania, które wymagają dużo pracy przy implementacji, ale są wolne od niejasności, co eliminuje niepotrzebną nadmiarową obsługę.

Istnieje również podatek od orkiestracji. Pisanie kodu jest tanie, ważna jest specyfikacja, a testowanie i akceptacja wyników stanowią nowy wąskie gardło. Inni w tej dziedzinie wydają się się z tym zgadzać. Zespoły mogą albo wyprzedzić ten trend, albo zostać przez niego przytłoczone.

Dla tych, którzy chcą spróbować tego podejścia, punktem wyjścia jest aplikacja desktopowa Antigravity 2.0, która oferuje gotowe do użycia narzędzie do wizualnej orkiestracji wielu ścieżek.