Insights AI

Skalowanie autonomicznych agentów programistycznych: jak pętle weryfikacji i rygorystyczne zabezpieczenia ciągłej integracji umożliwiają szybkie dostarczanie oprogramowania

Podcast · Słuchaj (20 min)

Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明

Spis treści
  1. Wąskie gardło zaufania: dlaczego skalowanie agentów programistycznych jest problemem zarządzania zespołami inżynierskimi
  2. 1. Ujęcie istoty problemu
  3. 2. Przedstawienie analogii do zarządzania
  4. Programowa weryfikacja i mapowanie funkcjonalności: domknięcie pętli agenta
  5. 1. Wyjaśnienie mechanizmu weryfikacji krok po kroku
  6. 2. Szczegółowy opis architektury mapy funkcjonalności
  7. 3. Szczegółowy opis oceny i utrzymania umiejętności agentów
  8. Twarde zabezpieczenia architektoniczne: przejście od miękkich instrukcji do egzekwowania przez CI
  9. 1. Porównanie miękkich reguł z twardymi ograniczeniami deterministycznymi
  10. 2. Analiza studium przypadku architektury „Dune”
  11. Automatyzacja agentów chmurowych i implikacje produktowe dla całej branży
  12. 1. Autonomiczne odtwarzanie błędów i przepływy pracy w chmurze
  13. 2. Demokratyzacja tworzenia oprogramowania wśród osób na stanowiskach nieinżynierskich
  14. Ograniczenia architektoniczne i otwarte kwestie inżynierskie
  15. 1. Dokumentowanie kluczowych ograniczeń i przypadków brzegowych
  16. Kluczowe liczby
  17. Co zmieniłoby ten obraz
  18. Źródła

Współczesne organizacje inżynierii oprogramowania dokonują fundamentalnej zmiany paradygmatu, przechodząc od mikrozarządzanego programowania w parach ze sztuczną inteligencją [AI] do autonomicznych flot agentów zdolnych do wprowadzania od setek do tysięcy żądań scalenia [PR] miesięcznie. Jak wyjaśniła Lauren Tan, inżynierka w SpaceXAI, skalowanie generowania kodu przez AI jest przede wszystkim problemem zarządzania zespołami inżynierskimi, a nie prostym ćwiczeniem z formułowania instrukcji. Gdy zespoły inżynierskie polegają na ręcznym nadzorze, przeglądach kodu wiersz po wierszu i miękkich wytycznych dotyczących instrukcji, programista staje się synchronicznym wąskim gardłem ograniczającym skalowanie agentów. Przejście do wysoce autonomicznego wykonywania zadań wymaga zastąpienia nadzoru człowieka programowymi pętlami weryfikacji, uporządkowanym mapowaniem funkcjonalności i deterministycznymi zabezpieczeniami ciągłej integracji [CI]. Dzięki zakodowaniu niezmienników architektonicznych bezpośrednio w narzędziach analizy statycznej i środowiskach weryfikacji działania zespoły inżynierskie mogą delegować wykonanie równoległym agentom chmurowym, jednocześnie systematycznie zapobiegając degradacji bazy kodu.

Wąskie gardło zaufania: dlaczego skalowanie agentów programistycznych jest problemem zarządzania zespołami inżynierskimi

1. Ujęcie istoty problemu

Głównym źródłem trudności w dostarczaniu oprogramowania wspomaganym przez AI jest brak zaufania programistów do wyników pracy agentów. Agenci programistyczni często wymyślają abstrakcje, błędnie diagnozują przyczyny źródłowe i z przekonaniem proponują nieprawidłowe poprawki. Jak zauważyła Lauren Tan podczas wywiadu na kanale YouTube Vision Sabbat, agenci często „z przekonaniem twierdzą, że po raz setny znaleźli niezbity dowód”, podczas gdy zasadniczy problem pozostaje całkowicie nierozwiązany.

Gdy zespoły inżynierskie próbują skalować wykorzystanie agentów poprzez tradycyjne programowanie w parach z udziałem człowieka w pętli, proces szybko osiąga nieprzekraczalny pułap. Jeśli inżynier musi sprawdzać każdy wygenerowany wiersz kodu, ręcznie testować lokalne kompilacje i weryfikować różnice w kodzie, programista staje się pojedynczym punktem wymuszającym sekwencyjne wykonywanie pracy. To synchroniczne wąskie gardło ogranicza skalowanie powyżej jednego lub dwóch lokalnych agentów, uniemożliwiając rzeczywiste zrównoleglenie procesów inżynierskich.

2. Przedstawienie analogii do zarządzania

Analizując tę dynamikę operacyjną, Lauren Tan wskazała bezpośrednią analogię między zarządzaniem agentami programistycznymi AI a zarządzaniem inżynierami oprogramowania. W tradycyjnym zarządzaniu zespołami inżynierskimi menedżer, który nie ufa bezpośrednim podwładnym, nieuchronnie ucieka się do mikrozarządzania — zagląda programistom przez ramię, nieustannie kontroluje żądania scalenia i sprawdza każdy wiersz kodu, aby zapobiegać awariom produkcyjnym.

       HIGH |                                     [ Fleet Autonomy ]
            |                                     Auto-merging PRs &
            |                                     Cloud Parallelization
   TRUST    |                                  /
            |                             /
            |                        /
            |   [ Micromanagement ]
        LOW |   Manual Prompting & 1-in-Loop
            +---------------------------------------------------
                LOW                                     HIGH
                               VELOCITY

Skalowanie autonomii agentów wymaga wspinania się po tym, co Tan określa jako „krzywą zaufania”. W początkowej fazie wdrażania agentów programiści działają synchronicznie wewnątrz pętli wykonania, ręcznie wydając instrukcje poszczególnym agentom i sprawdzając każdą różnicę w kodzie. Wspinanie się po krzywej zaufania wymaga tworzenia systemów zapewniających obiektywną, zautomatyzowaną weryfikację wyników pracy agentów. Zbudowanie wysokiego zaufania zmienia paradygmat organizacyjny z synchronicznego mikrozarządzania na asynchroniczne delegowanie, umożliwiając autonomicznym flotom agentów chmurowych samodzielne tworzenie, testowanie i scalanie kodu.

Programowa weryfikacja i mapowanie funkcjonalności: domknięcie pętli agenta

1. Wyjaśnienie mechanizmu weryfikacji krok po kroku

W architekturach inżynierii agentowej programowa weryfikacja oznacza zapewnienie agentom konkretnych narzędzi wykonawczych do bezpośredniej interakcji ze środowiskami wykonawczymi aplikacji docelowych. Zamiast prosić duży model językowy [LLM] o odgadnięcie, czy jego kod działa prawidłowo, programowa pętla weryfikacji pozwala agentowi uruchamiać kompilacje, sprawdzać środowiska wykonawcze, rejestrować ślady wydajności procesora [CPU], analizować migawki pamięci sterty oraz obsługiwać symulatory urządzeń mobilnych lub przeglądarek. W przypadku aplikacji internetowych i komputerowych agenci wykorzystują umiejętności zbudowane na protokołach takich jak Chrome DevTools Protocol [CDP], aby programowo sterować interfejsem użytkownika [UI].

Lauren Tan zilustrowała ten mechanizm analogią kulinarną: poleganie na agencie bez programowej weryfikacji przypomina sytuację, w której kierownik restauracji czyta papierowe przepisy, aby odgadnąć, czy potrawa dobrze smakuje, podczas gdy programowa weryfikacja wyposaża szefa kuchni w stanowiska kuchenne umożliwiające ciągłe próbowanie, odmierzanie i korygowanie potraw w trakcie przygotowania. Udostępnienie agentom narzędzi wykonawczych automatycznie domyka pętlę informacji zwrotnej. Choć weryfikacja nie gwarantuje elegancji architektury, deterministycznie potwierdza poprawność zachowania przed przeglądem kodu przez człowieka.

2. Szczegółowy opis architektury mapy funkcjonalności

Kluczowym elementem programowej weryfikacji wprowadzonym w otwartoźródłowej wtyczce PStack (Potato Stack) autorstwa Tan — narzędziu umiejętności programistycznych, którego nazwa nawiązuje do GStack Gary’ego Tana — jest „mapa funkcjonalności”. Mapa funkcjonalności rozwiązuje problem poruszania się po bazie kodu, z którym agenci stykają się podczas prób usuwania błędów lub wdrażania funkcjonalności w złożonych systemach.

+-----------------------------------------------------------------------+
|                             FEATURE MAP                               |
+-----------------------------------------------------------------------+
|  User Context / Vague Report: "Left sidebar is laggy on click"         |
+-----------------------------------------------------------------------+
                                  |
                                  v
+-----------------------------------------------------------------------+
|  DOM Attributes & Selectors : [data-testid="sidebar-toggle"]          |
|  Keyboard Shortcuts         : Cmd+B / Ctrl+B                          |
|  Code Base Location         : src/components/sidebar/Sidebar.tsx      |
|  CDP Execution Action       : cdp.click('#sidebar-toggle')            |
+-----------------------------------------------------------------------+

Gdy użytkownicy przesyłają niskiej jakości, niejednoznaczne zgłoszenia błędów — takie jak zrzut ekranu ze Slack opatrzony jedynie „???” — agent pozbawiony kontekstu strukturalnego ma trudności ze znalezieniem odpowiednich komponentów. Mapa funkcjonalności bezpośrednio wypełnia tę lukę, przypisując elementy UI do ścieżek plików w bazie kodu, atrybutów obiektowego modelu dokumentu [DOM], identyfikatorów testowych, skrótów klawiaturowych i selektorów wykonawczych CDP.

Za pomocą umiejętności takich jak create_verification_skill i maintain_verification_skill w PStack agenci systematycznie analizują bazy kodu, aby tworzyć uporządkowane rejestry funkcjonalności. Przyjęcie niejednoznacznego zgłoszenia błędu pozwala agentowi zestawić je z mapą funkcjonalności, przejść bezpośrednio do docelowych elementów UI, wykonać sekwencje interakcji przez CDP, zebrać wskaźniki wydajności i zweryfikować usunięcie usterki.

3. Szczegółowy opis oceny i utrzymania umiejętności agentów

Aby utrzymywać narzędzia i umiejętności agentów w czasie, zespoły programistyczne muszą wdrażać zautomatyzowane środowiska oceny, które działają jak testy jednostkowe umiejętności agentów AI. Procedura oceny przebiega według czteroetapowego schematu:

  1. Tworzenie kryteriów oceny: Agent koordynujący ustala jednoznaczny zestaw kryteriów oceny określający oczekiwane zachowania narzędzi i ilościowe zasady punktacji.
  2. Wykonywanie zadań w izolowanym środowisku: Agenci podrzędni wykonują zadania w izolowanych katalogach tymczasowych o losowych, zaciemnionych nazwach. Zaciemnianie nazw katalogów jest bezwzględnie wymagane, ponieważ modele LLM potrafią wykryć, że działają w środowisku oceny, i zmienić sposób wykonywania zadań, wprowadzając poważne zniekształcenie wyników oceny.
  3. Ocena w macierzy wielu modeli: Aby wyeliminować stronniczość punktacji pojedynczego modelu, agenci oceniający działający w macierzy różnych modeli bazowych oceniają wyniki agentów podrzędnych według kryteriów koordynatora.
  4. Pętle optymalizacji metodą wspinaczki: Zautomatyzowane pętle optymalizacji (takie jak wykonywanie /loop w Cursor) stale udoskonalają instrukcje umiejętności i parametry narzędzi, aż do osiągnięcia docelowych wyników oceny (np. 10 na 10) w całej macierzy modeli.

Tan podkreśliła, że utrzymywanie umiejętności agentów wymaga ciągłej obserwacji przez człowieka i wyczucia inżynierskiego. Programiści muszą aktywnie nadzorować pracę agentów, sprawdzając rejestry wywołań narzędzi i bloki rozumowania agentów podczas rozwijania umiejętności, aby identyfikować subtelne tryby błędów i formalizować instrukcje korygujące jako trwałe umiejętności.

Twarde zabezpieczenia architektoniczne: przejście od miękkich instrukcji do egzekwowania przez CI

1. Porównanie miękkich reguł z twardymi ograniczeniami deterministycznymi

Poleganie wyłącznie na miękkich ograniczeniach zawartych w instrukcjach — takich jak przewodniki stylu w formacie markdown, reguły instrukcji czy pliki instrukcji AGENTS.md — nieuchronnie prowadzi do degradacji bazy kodu. Gdy nieograniczeni agenci wybierają drogę najmniejszego oporu, aby wykonać zadania o lokalnym zakresie, tworzą „architekturę organiczną” charakteryzującą się nieprawidłowymi abstrakcjami, powieloną logiką i narastającym długiem technicznym.

Aby zachować długoterminową integralność strukturalną, architektury oprogramowania muszą wdrożyć podstawowy paradygmat projektowy Lauren Tan: ponieważ agenci naturalnie wybierają skróty strukturalne, architektura bazy kodu musi być zaprojektowana tak, aby najkrótsza ścieżka była strukturalnie najlepszą i poprawną ścieżką. Zespoły inżynierskie muszą egzekwować ten paradygmat poprzez wielowarstwowy system zabezpieczeń, który przenosi ciężar z miękkich wytycznych na twarde kontrole CI.

Warstwa Poziom egzekwowania Mechanizm / narzędzia Charakterystyka
1. Architektura bazy kodu i hermetyzacja Twardy (deterministyczny) Współlokowanie funkcjonalności, ścisłe granice katalogów, niestandardowe reguły importu Strukturalnie zapobiega antywzorcom architektonicznym, sprawiając, że najkrótsza ścieżka jest ścieżką poprawną
2. Analiza statyczna i diagnostyka kompilatora Twardy (deterministyczny) Rygorystyczne kompilatory (np. kontroler pożyczania w Rust), niestandardowe narzędzia kontroli kodu, kontrole CI Deterministycznie przerywa kompilacje przy naruszeniach niezmienników przed przeglądem przez człowieka
3. Zautomatyzowany przegląd kodu Miękki / częściowo deterministyczny Recenzenci kodu AI (np. Bugbot), zautomatyzowana analiza PR Wykrywa usterki zależne od kontekstu podczas walidacji PR
4. Umiejętności agentów i przewodniki stylu Miękki (niedeterministyczny) Reguły w formacie markdown, instrukcje dla modeli, przewodniki stylu Łatwo ignorowane lub niespójnie stosowane przez modele

Choć miękkie wytyczne w warstwach 3 i 4 zapewniają pomocny kontekst, twarda analiza statyczna i hermetyzacja architektoniczna w warstwach 1 i 2 są niezbędne, aby zagwarantować, że autonomiczni agenci nie będą mogli scalać nieprawidłowego kodu.

2. Analiza studium przypadku architektury „Dune”#

Praktyczne wdrożenie deterministycznych zabezpieczeń pokazuje refaktoryzacja aplikacji komputerowej Grokbot. Grokbot powstał z wykorzystaniem „Dune”, wyspecjalizowanej wewnętrznej platformy określanej jako Next.js dla aplikacji Electron, zaprojektowanej specjalnie z myślą o dostarczaniu oprogramowania przez agentów.

Aby chronić wydajność aplikacji podczas działania i eliminować powtarzające się tryby błędów agentów, architektura Dune egzekwuje ścisłe reguły deterministyczne w potokach CI:

  • Zakaz stosowania mechanizmów zaczepów React: Zaczep useEffect w React jest całkowicie zabroniony w całej bazie kodu, aby zapobiegać błędom synchronizacji stanu i niezamierzonemu ponownemu renderowaniu. Kompilacje CI są natychmiast przerywane po wykryciu useEffect.
  • Zakaz komentarzy w kodzie: Komentarze w kodzie aplikacji są surowo zabronione. Tan zauważyła, że agenci często generują komentarze historyczne lub błędnie interpretują przejściowe uwagi z przeglądów żądań scalenia — na przykład przekształcając pojedynczą uwagę z przeglądu, taką jak "Lauren said never to do this", w statyczny komentarz w kodzie — co prowadzi do wymyślania trwałych, globalnych ograniczeń i zanieczyszczania okien kontekstowych modeli. Zakaz komentarzy wymusza tworzenie samodokumentującego się kodu i zapobiega degradacji kontekstu.
  • Wymuszona izolacja granic procesów: Aplikacje Electron wymagają ścisłego oddzielenia głównego procesu node od wątku renderującego UI. Aby chronić budżet wykonania wynoszący 16 milisekund na klatkę, niezbędny do utrzymania płynności na poziomie 60 klatek na sekundę [FPS], operacje wymagające dużej mocy obliczeniowej i zadania wejścia/wyjścia [IO] są zabronione w wątku renderującym. Dune egzekwuje to poprzez izolowanie logiki w katalogach electron_main i electron_renderer oraz stosowanie zautomatyzowanych kontroli grafu zależności w CI do blokowania importów między katalogami.

Automatyzacja agentów chmurowych i implikacje produktowe dla całej branży

1. Autonomiczne odtwarzanie błędów i przepływy pracy w chmurze

Wdrożenie lokalnych narzędzi weryfikacyjnych i rygorystycznych zabezpieczeń w ramach ciągłej integracji umożliwia przejście od lokalnego wydawania poleceń do flot autonomicznych agentów działających w chmurze w procesie dostarczania oprogramowania. Przykładem tej zmiany są wewnętrzni agenci automatyzacji w chmurze, tacy jak „Benny” w Cursor.

  [ User Feedback ] (Slack / Support Channels)
         |
         v
  [ Benny Cloud Agent ] (Spawns Isolated Cursor Cloud Environment)
         |
         v
  [ Execute Verification Skill ] (Launches App, Simulates UI Input)
         |
         +---> Bug Reproduced? ---> Yes ---> Generate Fix & Submit PR
         |
         +---> Already Fixed on Main? ---> Confirm Resolution & Notify Team

Benny automatycznie pobiera nieprzetworzone opinie użytkowników i zgłoszenia usterek z kanałów Slack. Po otrzymaniu zgłoszenia Benny uruchamia odizolowaną instancję aplikacji komputerowej Cursor w chmurze, uruchamia środowisko wykonawcze aplikacji i wykorzystuje zapisane umiejętności weryfikacyjne, aby programowo odtworzyć zgłoszoną usterkę.

Działanie w odizolowanym środowisku wyposażonym w pełne możliwości weryfikacji pozwala Benny samodzielnie określić, czy problem nadal występuje, czy został już rozwiązany w głównej gałęzi kodu. Automatyzacja ta eliminuje konieczność ręcznego odtwarzania przez inżynierów problemów opisanych w niskiej jakości zgłoszeniach użytkowników.

2. Demokratyzacja tworzenia oprogramowania wśród osób na stanowiskach nieinżynierskich

Deterministyczne zabezpieczenia ciągłej integracji zasadniczo zmieniają dynamikę działania organizacji zajmujących się rozwojem produktów. Gdy niezmienniki architektoniczne, granice pamięci i budżety wydajnościowe są egzekwowane deterministycznie przez kompilatory i skrypty ciągłej integracji, pracownicy spoza zespołów inżynierskich — w tym menedżerowie produktu, projektanci doświadczeń użytkownika i osoby odpowiedzialne za wprowadzanie produktów na rynek — mogą bezpiecznie tworzyć funkcje i składać wnioski o scalenie zmian przeznaczonych do wdrożenia produkcyjnego.

Ponieważ infrastruktura automatycznie odrzuca niezgodne implementacje, osoby bez kompetencji technicznych mogą tworzyć usprawnienia funkcjonalne za pomocą interfejsów języka naturalnego, takich jak Grokbot, bez zagrażania stabilności bazy kodu ani budżetom wydajnościowym.

Ten model operacyjny wiąże się z określonymi kompromisami ekonomicznymi i dotyczącymi zwrotu z inwestycji:

  • Początkowe nakłady kapitałowe na tokeny: Tworzenie kompleksowych zestawów weryfikacyjnych, wykonywanie wieloagentowych macierzy oceny i przeprowadzanie refaktoryzacji strukturalnej wymaga znacznych początkowych wydatków na tokeny. Refaktoryzacja aplikacji Grokbot do architektury Dune wymagała ponad 600 odrębnych wniosków o scalenie zmian.
  • Wzrost efektywności pracy: Wysokie początkowe wydatki na tokeny są równoważone przez radykalne ograniczenie nakładu pracy inżynierów. Wysokowydajne potoki wykonywania zadań przez agentów pozwalają organizacjom działać z niewielkimi zespołami, unikając narzutów organizacyjnych związanych z dużymi działami inżynierskimi. Opłacalność ciągłych pętli oceny i macierzy oceny agentów dodatkowo zwiększają najnowocześniejsze modele, takie jak Grok 4.6, który utrzymuje ceny tokenów z wersji 4.5, zapewniając jednocześnie lepsze wyniki w testach porównawczych.

Ograniczenia architektoniczne i otwarte kwestie inżynierskie

1. Dokumentowanie kluczowych ograniczeń i przypadków brzegowych

Pomimo przyspieszenia prac osiągniętego dzięki flotom agentów o wysokiej autonomii obecne wzorce architektoniczne wprowadzają wyraźne ograniczenia i kompromisy inżynierskie:

  • Początkowy koszt tokenów: Budowanie potoków ciągłej weryfikacji i przeprowadzanie refaktoryzacji obejmujących setki wniosków o scalenie zmian pochłania ogromne ilości tokenów. W przypadku zespołów działających przy ograniczonych budżetach na tokeny kapitał niezbędny do stworzenia narzędzi weryfikacyjnych może stanowić istotną barierę przed osiągnięciem zwrotu z inwestycji.
  • Ryzyko prototypowania od podstaw: Szybkie prototypowanie aplikacji bez zabezpieczeń strukturalnych („programowanie na wyczucie”) generuje poważny architektoniczny dług techniczny. Przy braku wyraźnych granic hermetyzacji i ograniczeń statycznych agenci wybierają wygodne skróty, które sprawiają, że bazy kodu szybko wymykają się spod kontroli, ostatecznie wymagając ogromnych prac refaktoryzacyjnych obejmujących setki wniosków o scalenie zmian w celu naprawienia sytuacji.
  • Nakład pracy związany z utrzymaniem i wyczuciem inżynierskim: Zautomatyzowane systemy weryfikacji nie eliminują potrzeby wyczucia doświadczonych inżynierów. Tworzenie ocen, aktualizowanie map funkcji i ustanawianie ograniczeń ciągłej integracji wymagają głębokiej wiedzy dziedzinowej oraz aktywnego nadzoru i bieżącego ukierunkowywania działań.

Kluczowe liczby#

  • 1,000 wniosków o scalenie zmian: Liczba wniosków o scalenie zmian włączonych do kodu przez Lauren Tan w poprzednim miesiącu przy użyciu autonomicznych agentów w Cursor.
  • Niemal 800 wniosków o scalenie zmian: Liczba wniosków o scalenie zmian włączonych do kodu przez Lauren Tan w bieżącym miesiącu (według stanu na 12. dzień miesiąca).
  • 20 wniosków o scalenie zmian: Liczba wygenerowanych przez agentów wniosków o scalenie zmian automatycznie scalonych w nocy i zweryfikowanych w głównej gałęzi kodu w ciągu jednego dnia.
  • 600+ wniosków o scalenie zmian: Liczba wniosków o scalenie zmian zrealizowanych w celu ukończenia pełnej refaktoryzacji architektury bazy kodu Grokbot.
  • 16 milisekund: Maksymalne okno wykonania na klatkę wymagane w wątku renderowania Electron, aby utrzymać płynne działanie interfejsu użytkownika przy 60 klatkach na sekundę.
  • 5 miesięcy temu: Moment dołączenia Lauren Tan do Cursor; początkowo jej produktywność była niska, gdy budowała zaufanie do agentów i rozwijała podstawowe umiejętności weryfikacyjne.
  • Grok 4.6: Nowo ogłoszona wersja modelu utrzymująca koszt tokenów z wersji modelu 4.5 przy jednoczesnym zwiększeniu wydajności w testach porównawczych.

Co zmieniłoby ten obraz

  1. Przejście na zabezpieczenia agentów wbudowane w kompilator: Powszechne przyjęcie języków podlegających rygorystycznej kompilacji, wyposażonych w ścisłe systemy własności pamięci i typów (takich jak Rust), zamiast dynamicznych platform programistycznych, przenoszące egzekwowanie reguł strukturalnych z niestandardowych skryptów ciągłej integracji bezpośrednio do diagnostyki kompilatora.
  2. Standaryzacja protokołów weryfikacji programowej: Szerokie przyjęcie w branży jednolitych, niezależnych od platformy standardów weryfikacji interakcji agentów z interfejsami użytkownika, wykraczających poza Chrome DevTools Protocol, w celu natywnego udostępnienia agentom sztucznej inteligencji interfejsów aplikacji komputerowych, mobilnych i internetowych.
  3. Powszechne autonomiczne scalanie w ramach ciągłej integracji: Przejście typowych zespołów tworzących oprogramowanie komercyjne z potoków ręcznego przeglądu kodu na w pełni zautomatyzowane kolejki scalania w ramach ciągłej integracji, sterowane syntetycznymi wynikami oceny i testami ciągłej integracji.
  4. Obniżenie kosztów tokenów w ocenach wieloagentowych: Znaczące strukturalne obniżenie kosztów wnioskowania modeli bazowych, umożliwiające zespołom programistycznym spoza dużych przedsiębiorstw ciągłe i opłacalne uruchamianie wieloagentowych macierzy oceny oraz pętli optymalizacji metodą wspinaczkową.

Aby dowiedzieć się więcej o wdrażaniu zaawansowanych struktur inżynierii sztucznej inteligencji i autonomicznych potoków wykonywania zadań, zapoznaj się z badaniami o otwartym kodzie źródłowym dostępnymi na stronie DeepValues Research lub wypróbuj aplikację DeepValues już dziś.

Źródła

Lauren Tan - SpaceXAI engineer, interview published on YouTube channel Vision Sabbat

Oglądaj

Linki do źródeł

Oglądaj i słuchaj

Tekst analizy: CC BY 4.0, cytuj jako: DeepValues Research, Skalowanie autonomicznych agentów programistycznych: jak pętle weryfikacji i rygorystyczne zabezpieczenia ciągłej integracji umożliwiają szybkie dostarczanie oprogramowania, https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-pl/

Bezpłatny cotygodniowy e-mail

Margin of Safety Weekly

W każdą sobotę otrzymasz e-mail: temperatura rynku, zakupy i sprzedaż wielkich inwestorów (raporty 13F), nowe analizy z tygodnia oraz nasze filmy i podcasty — bezpłatnie, bez konta.

Send me the DeepValues Margin of Safety Weekly, one email every Saturday. I can unsubscribe at any time. Information only, not investment advice. Prywatność

Sprawdź więcej

Przeprowadź tę analizę dla dowolnej akcji w 2 minuty

Deep Value Intelligence, wieloagentowy analityk AI stojący za tym raportem, przygotowuje na żądanie taki sam raport dla dowolnej spółki giełdowej.

Otwórz Deep Value Intelligence

Śledź 300+ akcji w aplikacji DeepValues

Oceny, wartość wewnętrzna i najnowsze raporty na telefonie.

Dla programistów: oceny i raporty przez API

Dane fundamentalne, wartości wewnętrzne, oceny i linki do raportów z tych stron w formacie JSON.

Dokumentacja API

Dyskutuj