AI agent framework eller egen kode?
Et agentframework som LangChain giver en hurtigere start, men tilføjer en abstraktion der koster ved fejlsøgning, versionsskift og fastlåsning i frameworkets mønstre. Tynd egen kode direkte mod model-API’erne giver mere kontrol når logikken er enkel. Uanset valget har du brug for værktøjer til evaluering og observability.
Når et team skal bygge sin første AI-agent, dukker spørgsmålet op tidligt: Skal vi bruge et framework som LangChain, eller skal vi selv skrive orkestreringen direkte mod model-API’erne? Det er et reelt vejvalg med konsekvenser for hvor let løsningen bliver at fejlsøge, vedligeholde og udskifte. Her gennemgår vi afvejningen og de værktøjer du har brug for uanset hvad du vælger.
Hvad valget egentlig står mellem
En AI-agent er grundlæggende et loop: Modellen får en opgave, vælger at kalde værktøjer, modtager resultater og fortsætter indtil den er færdig. Spørgsmålet er hvem der skriver det loop og limen omkring det.
Et agentframework giver færdige byggeklodser til netop det: forbindelser til værktøjer, håndtering af hukommelse, mønstre til at kæde kald sammen. Egen kode betyder at du selv bygger orkestreringen, tyndt og direkte mod API’et. Det første alternativ giver dig en hurtigere start. Det andet giver dig en mindre kodebase som du forstår i alle detaljer. Meget af beslutningen handler om at veje de to mod hinanden.
Frameworkenes abstraktionsomkostning
Frameworks bliver solgt på hvor meget de forenkler, og det holder i starten. Men abstraktionen har en pris der viser sig senere, og det er værd at gå ind til den med åbne øjne.
- Fejlsøgning. Når noget går galt, ligger fejlen nogle gange dybt inde i frameworket i stedet for i din egen kode. For at forstå hvad der faktisk skete, skal du så grave dig gennem lag som du ikke selv har skrevet.
- Versionsskift. Frameworks i hurtig udvikling ændrer adfærd fra version til version. En opdatering kan fremtvinge omskrivninger, og du binder dit tempo til en andens udgivelsestakt.
- Fastlåsning i mønstre. Din løsning formes efter frameworkets måde at tænke på. Jo mere I bygger, desto mere sidder I fast i dets abstraktioner, og desto sværere bliver det at skifte kurs senere.
Intet af dette gør frameworks til et dårligt valg. Pointen er at abstraktionsomkostningen er reel og betales over tid, ikke ved starten. Vej den mod den tid i opstarten som frameworket sparer.
Hvornår tynd egen kode er nok
For mange agenter er logikken faktisk ret enkel: nogle få trin, en håndfuld værktøjer, et klart flow. Så kan et fuldt framework blive mere en omvej end en hjælp.
Et konkret scenarie: I vil bygge en agent der tager et spørgsmål fra en kunde, slår svaret op i to interne systemer og sammensætter et svar. Det er en håndfuld kald i en overskuelig rækkefølge. En tynd egen orkestrering direkte mod model-API’et klarer hele opgaven, er let at fejlsøge og holder kodebasen lille. Her er egen kode ofte det hurtigere og mere holdbare valg, stik imod hvad man måske skulle tro.
Tommelfingerreglen: Jo enklere og mere forudsigeligt flowet er, desto stærkere er argumentet for egen kode. Jo mere dynamisk og forgrenet logikken bliver, desto mere kan et frameworks byggeklodser begynde at betale sig. Start hellere enkelt, og tilføj struktur når kompleksiteten faktisk kræver det, frem for at bygge til et behov I endnu ikke har.
Værktøjer du skal bruge uanset valg
Det her er den vigtigste indsigt, og den gælder uanset hvilken vej I vælger: To ting er nødvendige i begge tilfælde, og de bliver ofte undervurderet.
Den første er evaluering. I skal kunne afgøre om agenten gør det rigtige, og det kræver en testsuite med eksempler fra virkeligheden der køres systematisk, ikke bare en fornemmelse af at det “ser ud til at virke”. Uden det bliver hver ændring et gæt.
Den anden er observability. Når en agent laver fejl, skal I kunne se hvad den gjorde i hvert trin: hvilke kald, hvilke værktøjer, hvilke svar. Uden sporbarhed bliver fejlsøgning næsten umulig fordi agenter ofte fejler på uventede måder midt i en kæde.
Bemærk at intet af dette følger gratis med et framework. Evaluering og observability er selvstændige investeringer uanset om orkestreringen er egen kode eller bygget på LangChain. Regn dem med fra starten, så slipper I for at bygge dem i panik den dag agenten begynder at opføre sig uventet i produktion.
Vil I have hjælp til at designe arkitekturen for en AI-agent og træffe dette vejvalg på et solidt grundlag, kan I læse mere om vores arbejde med AI eller kontakte os.
Ofte stillede spørgsmål
Hvad er forskellen på et agentframework og egen kode?
Et agentframework som LangChain giver færdige byggeklodser til at koble modelkald, værktøjer og hukommelse sammen. Egen kode betyder at du selv skriver den orkestrering, tyndt og direkte mod model-API’erne. Frameworket sparer tid i opstarten, men tilføjer et lag der skal læres og vedligeholdes mens egen kode giver fuld kontrol over en mindre kodebase.
Hvornår er tynd egen kode nok?
Når agentens logik er overskuelig: nogle få trin, en håndfuld værktøjskald og et klart flow. Så bliver et fuldt framework ofte mere en omvej end en hjælp, og en tynd egen orkestrering direkte mod API’et er lettere at fejlsøge og eje. Jo enklere flowet er, desto stærkere er argumentet for egen kode.
Hvad er abstraktionsomkostningen ved et framework?
At abstraktionen skjuler hvad der faktisk sker. Det mærkes ved fejlsøgning når en fejl ligger dybt inde i frameworket i stedet for i din egen kode, og ved versionsskift når frameworket ændrer adfærd. Dertil kommer en fastlåsning: Din løsning formes efter frameworkets mønstre, og dem kan det være svært at forlade senere.
Hvilke værktøjer skal vi bruge uanset hvad vi vælger?
Evaluering og observability. Du skal kunne måle om agenten gør det rigtige (en testsuite med eksempler fra virkeligheden) og kunne se hvad den gjorde i hvert trin når noget går galt. De behov er uafhængige af om du bygger på et framework eller egen kode, og de bliver ofte undervurderet i starten.
Kan vi starte med egen kode og skifte til et framework senere?
Ofte ja, hvis I holder modelkaldene og logikken tydeligt adskilt fra starten. Så bliver et senere skifte til at håndtere hvis kompleksiteten vokser. Det omvendte, at forlade et framework, er som regel sværere fordi mere af løsningen har nået at blive formet efter dets mønstre. Start derfor hellere enkelt, og tilføj struktur når behovet er bevist.