Agyn-arkitekturen: Produktions-multi-agent gjort rätt

Agyn-arkitekturen: Produktions-multi-agent gjort rätt

Agyn optimerade inte för SWE-bench. De byggde en produktionsplattform för autonom mjukvaruutveckling och testade den sedan på benchmarket som validering. Resultatet: #1-prestanda bland GPT-5-klassmodeller, överträffar enagentsystem som OpenHands med 7,2% absolut. [2]

Deras hemlighet är inte bättre modeller—det är bättre organisation. Agyn-systemet använder fyra specialiserade agenter: Manager (uppgiftsuppdelning), Researcher (kodbas-analys), Engineer (implementation) och Reviewer (kvalitetskontroll). [1] Varje agent arbetar i isolerade sandlådor med definierade ansvarsområden och strukturerad kommunikation genom GitHub-primitiver.

Manager-agenten tar emot en GitHub-issue och skapar en projektplan med deluppgifter. Researcher-agenten analyserar kodbasen, identifierar relevanta filer och dokumenterar kontexten som behövs för implementation. Engineer-agenten skriver kod baserat på forskningen och skapar commits och pull requests. Reviewer-agenten granskar ändringarna, kör tester och antingen godkänner eller begär ändringar.

Det som får detta att fungera är infrastrukturen, inte bara rollerna. Varje agent har isolerade körmiljöer som förhindrar att en agents misstag sprider sig till andra. Kommunikation sker genom strukturerade GitHub-artefakter—pull requests, commits och kodkommentarer—snarare än flyktiga chattmeddelanden. Kontext sammanfattas och överförs mellan agenter genom definierade gränssnitt, inte ad-hoc-prompting.

Agyn-teamet fann att "att replikera teamstruktur, metodik och kommunikation är ett kraftfullt paradigm för autonom mjukvaruutveckling, och att framtida framsteg kan bero lika mycket på organisationsdesign och agentinfrastruktur som på modellförbättringar." [1] Denna insikt går emot den rådande visdomen att större modeller löser allt.

CAID: Git-nativ asynkron delegering som skalar

Medan Agyn bevisar att multi-agent-orkestrering fungerar i produktion, visar CMU:s CAID-ramverk (Centralized Asynchronous Isolated Delegation) hur man bygger det från första principer. CAID uppnår 26,7% absolut förbättring på PaperBench och 14,3% på Python-biblioteksuppgifter genom att grunda multi-agent-koordination i mjukvaruutvecklingsprimitiver. [4]

CAID-arkitekturen centreras kring en manager-agent som delegerar uppgifter till flera engineer-agenter som arbetar asynkront i isolerade git-arbetsträd. Varje engineer-agent får sin egen arbetsyta—en separat git-gren med sin egen beroende-miljö—vilket eliminerar konflikter och möjliggör parallellt arbete. [3]

Så här fungerar det i praktiken: Managern tar emot en komplex uppgift som "implementera OAuth2-autentisering med hastighetsbegränsning." Den delar upp detta i deluppgifter: skapa databasschema, implementera auth-middleware, lägga till hastighetsbegränsningslogik, skriva tester, uppdatera dokumentation. Varje deluppgift tilldelas en engineer-agent i sitt eget git-arbetsträd.

Engineers arbetar asynkront och gör commits till sina isolerade grenar. När en engineer slutför sin deluppgift granskar managern ändringarna och antingen slår samman dem eller begär ändringar. Beroenden mellan deluppgifter hanteras genom git-merge-processen—om auth-middleware beror på databasschemat sker den sammanslagningen först.

CAID-repositoriet tillhandahåller en komplett implementation med Docker-arbetsytor, LiteLLM-stöd för flera modellleverantörer och modulära uppgiftsgränssnitt. [4] Du kan köra det lokalt med uv sync och miljövariabler för dina modell-API-nycklar. Kodbasen demonstrerar praktiska mönster: arbetsyteisolering, beroendehantering, uppgiftsuppdelning och resultatsammanställning.

Orkestreringsmönster som faktiskt fungerar

Både Agyn och CAID lyckas eftersom de implementerar en liten uppsättning beprövade designmönster. Vinsterna kommer inte från prompt engineering eller modellfinjustering—de kommer från arkitektoniska beslut som speglar hur mänskliga utvecklingsteam faktiskt arbetar. [6]

Isolerade körmiljöer förhindrar att agentmisstag sprider sig. När en agent förstör bygget eller korrumperar tillstånd fortsätter andra agenter att arbeta i sina egna sandlådor. Denna felisolering är kritisk för tillförlitlighet i produktionssystem.

Explicita rolldefinitioner ger varje agent tydliga ansvarsområden och framgångskriterier. Agyn Researcher skriver inte kod; den analyserar kodbaser och dokumenterar fynd. Engineer fattar inte arkitektoniska beslut; den implementerar baserat på forskning och krav. Dessa gränser förhindrar rollförvirring och förbättrar outputkvaliteten.

Strukturerad kommunikation genom GitHub-artefakter skapar beständiga, granskningsbara register över agentbeslut. Till skillnad från chattbaserad koordination ger pull requests och kodkommentarer kontext som kvarstår över agentsessioner och kan granskas av mänskliga utvecklare.

Kontexthantering för långvariga uppgifter löser problemet med agenternas minnesbegränsningar. Istället för att stoppa in hela kodbaser i kontextfönster sammanfattar agenter sina fynd och överför strukturerad data genom definierade gränssnitt. Agyn Researcher skapar dokumentation som Engineer kan referera till utan att återanalysera kodbasen.

Dessa mönster fungerar eftersom "mjukvaruutveckling är en kollaborativ process. Arbete delas upp mellan roller, koordination sker genom delade artefakter och framsteg uppstår genom iteration och granskning." [6] AI-system som respekterar dessa realiteter överträffar de som behandlar kodning som en soloaktivitet.

Byggarens implementationsguide

Redo att distribuera multi-agent-orkestrering? Börja med open source-grunderna och bygg upp till produktionsmönster.

För experiment, klona CAID-repositoriet och kör exemplen. [4] Installationen kräver Python 3.11+, Docker för arbetsyteisolering och API-nycklar för dina föredragna språkmodeller. Repositoriet inkluderar uppgifter för pappersreproduktion och Python-biblioteksutveckling som demonstrerar kärnmönstren.

För produktionsdistribution, studera Agyn-plattformsarkitekturen. [5] Även om deras fullständiga plattform inte är open source dokumenterar deras blogg de viktigaste designbesluten: agentrolldefinitioner, sandlådeisoleringsstrategier, GitHub-integrationsmönster och kontexthanteringsmetoder.

Fokusera på git-nativa arbetsflöden från början. Båda framgångsrika systemen grundar sin orkestrering i mjukvaruutvecklingsprimitiver—grenar, commits, sammanslagningar, pull requests. Detta är inte bara för kompatibilitet med befintliga verktyg; det beror på att dessa primitiver kodar årtionden av lärande om hur man koordinerar komplexa mjukvaruändringar.

Mät det som spelar roll: end-to-end-uppgiftsslutförande, inte agentkvalitet. SWE-bench-benchmarket testar om agenter faktiskt kan fixa riktiga GitHub-issues, inte om deras resonemang låter rimligt. Bygg din utvärderingsram innan du bygger dina agenter.

Börja med snäva domäner där du kan definiera tydliga framgångskriterier. Både Agyn och CAID fungerar eftersom de tacklar väldefinierade mjukvaruutvecklingsuppgifter med mätbara resultat. Försök inte bygga ett allmänt AI-team; bygg ett specialiserat team för ditt specifika användningsfall.

Fallstudier: Multi-agent-team i verkligheten

Forskningsartiklarna tillhandahåller benchmarks, men vad gäller verklig distribution? Tidiga användare ser praktiska vinster över olika typer av mjukvaruutvecklingsarbete.

API-integrationsuppgifter fungerar särskilt bra för multi-agent-system. En agent forskar i mål-API-dokumentationen och skapar integrationsspecifikationer. En annan agent implementerar klientkoden baserat på dessa specifikationer. En tredje agent skriver omfattande tester och hanterar felfall. Isoleringen förhindrar att API-hastighetsbegränsning blockerar andra arbetsströmmar.

Modernisering av legacy-kodbaser drar nytta av den forskningstunga metoden. Researcher-agenter kan analysera föråldrade beroenden och dokumentera migreringsvägar utan att röra produktionskod. Engineer-agenter kan implementera ändringar i isolerade grenar. Reviewer-agenter kan validera att nya implementationer bibehåller beteendekompatibilitet.

Dokumentationsgenerering visar de kollaborativa fördelarna. En agent analyserar kodstruktur och identifierar odokumenterade funktioner. En annan agent skriver initial dokumentation baserat på kodanalys. En tredje agent granskar dokumentationen för noggrannhet och fullständighet, korshänvisar med faktiska användningsmönster i kodbasen.

Den gemensamma tråden: uppgifter som drar nytta av specialisering och parallellt arbete ser de största vinsterna från multi-agent-orkestrering. Soloagenter kämpar med kontextväxling mellan forskning, implementation och granskning. Specialiserade agenter bibehåller fokus och producerar högkvalitativa outputs inom sina domäner.

Vad förändras när AI bygger mjukvaran

Skiftet från soloagenter till AI-team representerar mer än en inkrementell förbättring av kodningsautomation. Det är framväxten av AI-system som kan hantera mjukvaruutvecklingens fulla komplexitet: forskning, arkitektur, implementation, testning och granskning. [1]

Detta förändrar ekonomin för mjukvaruutveckling på sätt vi bara börjar förstå. När AI-team tillförlitligt kan fixa GitHub-issues och implementera funktioner skiftar flaskhalsen från att skriva kod till att definiera krav och fatta arkitektoniska beslut. Kod blir gratis; omdöme blir allt.

För nordiska teknikföretag som redan leder inom AI-adoption representerar detta en betydande konkurrensfördel. Förmågan att distribuera AI-team för rutinmässiga mjukvaruutvecklingsuppgifter frigör mänskliga utvecklare att fokusera på produktstrategi, användarupplevelse och affärslogik. Det är automation som förstärker mänskliga förmågor snarare än ersätter dem.

Men implikationerna går djupare. Multi-agent-orkestreringsmönster som fungerar för mjukvaruutveckling kommer sannolikt att fungera för annat komplext, kollaborativt kunskapsarbete. Samma principer—rollspecialisering, isolerad exekvering, strukturerad kommunikation, kontexthantering—gäller för forskning, analys, innehållsskapande och strategisk planering.

Byggarna som bemästrar dessa orkestreringsmönster idag kommer att forma hur AI-system tacklar komplexa problem imorgon. Frågan är inte om AI kommer att automatisera mjukvaruutveckling—system som Agyn och CAID bevisar att det redan händer. Frågan är om du kommer att bygga omdömet för att orkestrera dessa förmågor effektivt.

Post-kod-eran betyder inte ingen mer programmering. Det betyder att programmering blir en aktivitet på högre nivå: att designa AI-team, definiera deras interaktioner och säkerställa att deras outputs tjänar mänskliga mål. Framtiden tillhör de som kan arkitekturera intelligens, inte bara tillämpa den.

Källor

1. https://arxiv.org/abs/2602.01465
2. https://agyn.io/blog/we-tested-ai-team-swe-bench-verified
3. https://arxiv.org/abs/2603.21489
4. https://github.com/JiayiGeng/CAID
5. https://agyn.io/blog
6. https://agyn.io/blog/multi-agent-orchestration-patterns-that-actually-work
7. https://www.swebench.com/