Sådan bygger du skræddersyede AI-agenter: arkitektur, mønstre og skalering

Trin 1: Definér AI-agentens arkitektur og styringsramme

En AI-agentarkitektur består af to hoveddele: modellen og tjenesten omkring den. Tjenesten omfatter modellen samt dens værktøjer, hukommelse og øvrige komponenter. Den fungerer som hardkodet, deterministisk software med if/else-logik bygget op omkring selve modellen.

Forskellen er tydelig. Når teams lærer at bygge skræddersyede AI-agenter, begår de ofte den fejl at bede modellen om at klare det hele. Det giver alvorlige problemer med driftssikkerheden.

Det går hurtigt galt. Modellen genererer tekst, men styringsrammen udfører logikken. Derfor skal du behandle modellen som en isoleret ræsonnementsmotor, der aldrig rører din kode til routing.

Styringsrammen håndterer tilstand, routing og fejlgendannelse. Modellen træffer ikke beslutningerne. Da vi satte denne løsning i drift for en mellemstor SaaS-virksomhed, faldt tiden til at løse supportsager med 40 procent, fordi den deterministiske styringsramme håndterede routingen korrekt i stedet for at overlade den til modellens gæt.

Det var koden, der gjorde forskellen. Et klart systemflow gør adskillelsen lettere at se. Det er styringsrammen, ikke modellen, der bestemmer forløbet, så du har brug for en præcis plan for implementeringen.

Spring ikke den deterministiske logik over. Anthropic har udgivet en artikel om mulige designmønstre for AI-agenter, der dækker fire grundlæggende systemtyper: enkeltagenter, sekventielle arbejdsgange, parallelle arbejdsgange og evaluator-optimizer.

Vil du vide, hvordan du bygger skræddersyede AI-agenter, der kan skaleres? Du skal vælge et mønster, der passer til opgaven. Hvis én agent tvinges til at håndtere en parallel arbejdsgang med flere trin, bliver systemet markant langsommere. Enkeltagenter er gode til én opgave ad gangen.

• [ ] Definér deterministisk logik til routing
• [ ] Kortlæg adgangen til værktøjer via MCP
• [ ] Vælg grundmodel
• [ ] Design et skema for hukommelsens tilstand
• [ ] Konfigurér reserveløsninger ved fejl

Hvilket designmønster passer til din skræddersyede agent?

De er nemme at fejlfinde, men kan kun løse afgrænsede opgaver. Sekventielle arbejdsgange sender output fra én agent videre til den næste. Det fungerer godt til lineære processer som researchforløb, hvor hvert trin skal udføres i en bestemt rækkefølge.

I parallelle arbejdsgange udfører en gruppe AI-agenter opgaver asynkront og samtidigt, ligesom multithreading i traditionelle computermiljøer, for at reducere ventetiden. Det mønster gør komplekse opgaver markant hurtigere. I en evaluator-optimizer-arkitektur arbejder to agentsystemer i gentagne cyklusser: Gruppe A udfører opgaven, og gruppe B vurderer og forbedrer resultatet, omtrent som ved parprogrammering.

Det giver bedre resultater ved kode- og skriveopgaver. Her er et Python-eksempel på en parallel arbejdsgang, hvor agenter arbejder asynkront, så flere agenter kan køre uden at vente på, at de andre bliver færdige. Se koden nedenfor. `async def run_agent(task: str):`

# Simulate asynchronous agent task await asyncio.sleep(1)

import asyncio


return f"Result for {task}" async def parallel_workflow(tasks: list[str]): # Agents act asynchronously like multithreading results = await asyncio.gather(*[run_agent(task) for task in tasks])


return results tasks = ["fetch_market_data", "analyze_sentiment", "check_compliance"] results = asyncio.run(parallel_workflow(tasks)) print(results)

Overvej disse afvejninger, når du designer arbejdsgangen. Hvis du vil bygge en AI-agent med Claude, kan du kombinere Claude Agent SDK og Agent Skills. Det giver dig to væsentlige muligheder, når du undersøger, hvordan man bygger skræddersyede AI-agenter.

Vælg værktøjer med omhu. Du kan bruge Claude Agent SDK til tæt integration eller LangGraph til kompleks orkestrering af tilstandsmaskiner.

1. Svartid: Parallelle arbejdsgange forkorter den samlede tid markant.
2. Omkostninger: Parallelle arbejdsgange bruger flere tokens pr. sekund.
3. Nøjagtighed: Evaluator-optimizer-cyklusser øger nøjagtigheden, men fordobler beregningsbehovet.
4. Kompleksitet: Sekventielle arbejdsgange er nemmest at fejlfinde.

Trin 2: Vælg grundmodel og framework til orkestrering

Når du bygger agenter med Claude, er arbejdsdelingen enkel: SDK'et styrer løkken, værktøjer og MCP afgør, hvad agenten kan gøre, og Skills beskriver, hvordan den gør det. Claude Agent SDK giver dig en agentløkke, der indsamler kontekst, kalder modellen, kører et værktøj, sender resultatet tilbage og gentager processen. Den kan programmeres i Python eller TypeScript.

LangGraph giver mere kontrol. Her kan du definere eksplicitte knudepunkter for logikken og bygge faste sikkerhedsgrænser, som forhindrer modellen i at foretage uønskede værktøjskald.

Orkestreringslaget holder agenterne på sporet med nødvendige sikkerhedsgrænser. De kan kodes med værktøjer som LangGraph eller håndteres med grafiske værktøjer som Cursor Automations. Uden orkestrering kan en agent blive ved med at gentage den samme fejl i det uendelige.

Sikker håndtering af adgangsoplysninger er afgørende. Hardkod aldrig API-nøgler i systemprompten. I produktionssystemer skal de indsættes under kørslen via miljøvariabler.

Vi foretrækker LangGraph til kompleks routing. Det tvinger dig til at tage stilling til overgange mellem tilstande, mens Claude Agent SDK egner sig bedre til hurtige prototyper og værktøjstunge opgaver, der kræver hyppige justeringer.

{
 "orchestration": {
 "guardrails": {
 "max_iterations": 5,
 "timeout_seconds": 30
 },
 "secrets_manager": {
 "provider": "aws_secrets_manager",
 "keys": ["ANTHROPIC_API_KEY", "FIRECRAWL_API_KEY"]
 }
 }
}

Trin 3: Implementér værktøjer, webadgang og hukommelse

AI-agenter bruger MCP (Model Context Protocol), CLI-værktøjer og frameworks som LangChain til at få adgang til værktøjer. At kunne bygge skræddersyede AI-agenter indebærer også at kunne give dem et grundlag i virkelige, aktuelle oplysninger. Uden adgang til realtidsdata er deres viden begrænset til det, der ligger i hukommelsen og træningsdataene.

De indbyggede værktøjer til at hente webindhold fra virksomheder som OpenAI og Anthropic giver kun begrænset webadgang. Derfor er der behov for dedikerede værktøjer som Firecrawl. Rå HTML optager unødigt meget plads i konteksten og forvirrer modellen.

Firecrawl har tre centrale endpoints til webadgang: /search (søgning på nettet i realtid), /scrape (hentning af websites som strukturerede data eller Markdown) og /interact (åbning af en rigtig browser til at klikke på knapper og udfylde formularer).

På en typisk side giver Firecrawl cirka 2,788 tokens med ren Markdown i stedet for 38,381 tokens med rå HTML. Firecrawl bruger 94 procent færre inputtokens end hentning af rå HTML. Det forbedrer agentens ydeevne direkte.

Websiders struktur kan ændre sig, og siderne kan indeholde irrelevant navigation eller scripts. Foretræk et dokumenteret, struktureret endpoint, når det findes, og test udtrækket på repræsentative sider og ved ændringer i layoutet.

import requests


def search_web(query: str):
    response = requests.post("https://api.firecrawl.dev/v1/search", 
        json={"query": query, "limit": 5},
        headers={"Authorization": f"Bearer {API_KEY}"})
    return response.json()


def scrape_site(url: str):
    response = requests.post("https://api.firecrawl.dev/v1/scrape",
        json={"url": url, "formats": ["markdown"]},
        headers={"Authorization": f"Bearer {API_KEY}"})
    return response.json()

Hukommelse er afgørende for AI-systemer, der kører over længere tid, fordi alle modeller har et begrænset kontekstvindue, som nulstilles, når grænsen nås. Et kontekstvindue kan for eksempel rumme 200,000 tokens, hvorefter konteksten skal genopbygges ved hjælp af hukommelsen.

Du skal gemme samtalehistorik og tilstand i en ekstern database. Når kontekstvinduet er fyldt, henter du et resumé og de relevante oplysninger. Derefter bygger du prompten op igen. Gå aldrig ud fra, at modellen husker noget ud over det aktuelle input.

Hvordan styrer du omkostninger, API-nøgler og test?

Hvis du kører fem agenter samtidig, betaler du for fem modelkald på én gang. Single Agents koster mindre pr. kørsel, men er betydeligt længere om at blive færdige.

Du skal afveje hastighed mod budget. Lad os gennemgå et konkret eksempel med en supportagent, der håndterer en mellemstor mængde henvendelser: 10,000 kørsler om måneden, hvor manuel behandling koster $5 pr. sag, i alt $50,000.

Omkostningerne ved automatisering er sammensat anderledes.

Hosting koster $100. Investeringen tjener sig ind næsten med det samme. Test af agentens wrapper er ikke til forhandling. Du skal simulere fejl i værktøjerne og teste timeout-logikken grundigt, før du sætter noget i produktion.

Vi bruger deterministiske testcases til wrapperen og probabilistiske evalueringssuiter til modellen. Vi sætter aldrig en agent i drift uden at teste, hvordan den kommer sig efter fejl. Hold op med at overfylde systemprompter.

Agent Skills er mapper med en SKILL.md-fil, som lærer agenten at udføre specialiserede opgaver. De indlæses efter behov, så kontekstvinduet ikke fyldes med unødvendige instruktioner. Hvis du vil mestre udviklingen af skræddersyede AI-agenter, skal du adskille de forskellige ansvarsområder.

Den oversete pointe: Derfor hører viden om fremgangsmåder hjemme i Skills

Tankegangen bag udvikling af Claude-agenter er enkel: SDK'et styrer løkken, tools/MCP afgør, hvad agenten kan gøre, og Skills beskriver, hvordan den gør det. Tools er handlinger, Skills er manualer. Hvis du lægger alle instruktioner i systemprompten, spilder du plads i kontekstvinduet, fordi modellen læser instruktioner, den ikke har brug for til den aktuelle opgave.

Gradvis indlæsning løser problemet. Agenten indlæser kun SKILL.md-filen, når den skal udføre den pågældende opgave. Det holder kontekstvinduet slankt og mindsker risikoen for hallucinationer.

Det gør også dine agenter modulære. Du kan opdatere en skill uden at ændre den centrale orkestreringslogik.