Så bygger du anpassade AI-agenter: arkitektur, mönster och skalning

Steg 1: Definiera AI-agentens arkitektur och styrsystem

En AI-agents arkitektur består av två huvuddelar: modellen och tjänstens styrsystem. Styrsystemet omsluter modellen och innehåller verktyg, minne och övriga funktioner. Det är hårdkodad, deterministisk programvara med if/else-logik som byggs kring modellen.

Skillnaden är tydlig. När team lär sig bygga anpassade AI-agenter gör de ofta misstaget att låta modellen sköta allt, vilket leder till stora tillförlitlighetsproblem.

Det fungerar inte. Modellen genererar text, medan styrsystemet kör logik. Därför måste du behandla modellen som en fristående motor för resonemang som aldrig hanterar din kod för dirigering.

Styrsystemet hanterar tillstånd, dirigering och felåterhämtning. Modellen fattar inte de besluten. När vi driftsatte detta för ett medelstort SaaS-företag minskade tiderna för att lösa supportärenden med 40 procent, eftersom det deterministiska styrsystemet skötte dirigeringen i stället för att förlita sig på modellens gissningar.

Det var koden som gjorde skillnaden. Ett tydligt systemflöde gör uppdelningen lättare att se. Styrsystemet, inte modellen, bestämmer flödet. Därför behöver du en strikt plan för implementeringen.

Hoppa inte över de deterministiska beslutsgrindarna. Anthropic har publicerat en artikel om möjliga designmönster för AI-agenter. Den tar upp fyra grundtyper av system: enskilda agenter, sekventiella arbetsflöden, parallella arbetsflöden samt utvärderare och optimerare.

Vill du veta hur du bygger anpassade AI-agenter som går att skala upp? Välj mönster efter problemet. Om du tvingar en enskild agent att hantera ett parallellt arbetsflöde med flera steg blir systemets svarstid lidande. En enskild agent fungerar bra för en uppgift.

• [ ] Definiera deterministisk dirigeringslogik
• [ ] Kartlägg åtkomst till verktyg via MCP
• [ ] Välj grundmodell
• [ ] Utforma schema för minnestillstånd
• [ ] Konfigurera reservlösningar för felåterhämtning

Vilket designmönster passar din anpassade agent?

Enskilda agenter är lätta att felsöka men har ett begränsat användningsområde. I sekventiella arbetsflöden skickas resultatet från en agent vidare till nästa. Det passar linjära processer, som forskningsflöden där stegen måste utföras i en bestämd ordning.

I parallella arbetsflöden utför flera AI-agenter uppgifter asynkront och samtidigt, ungefär som flertrådning i traditionella datormiljöer. Det minskar svarstiden avsevärt för komplexa uppgifter. I mönstret utvärderare och optimerare arbetar två agentsystem i upprepade cykler: grupp A utför arbetet och grupp B granskar och förbättrar det, ungefär som vid parprogrammering.

Det ger bättre resultat för kodning och skrivande. Här är ett Python-exempel som konfigurerar ett parallellt arbetsflöde där agenter arbetar asynkront. Så kan du köra flera agenter utan att vänta på att de blir klara en i taget. Granska koden nedan. `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)

Väg dessa avvägningar när du utformar arbetsflödet. För att bygga en AI-agent med Claude kan utvecklare kombinera Claude Agent SDK och Agent Skills. Det ger dig två huvudsakliga vägar att utforska när du vill bygga anpassade AI-agenter.

Välj verktyg med omsorg. Claude Agent SDK ger tät integration, medan LangGraph passar komplex orkestrering med tillståndsmaskiner.

1. Svarstid: Parallella arbetsflöden minskar den totala tiden avsevärt.
2. Kostnad: Parallella arbetsflöden förbrukar fler token per sekund.
3. Träffsäkerhet: Cykler med utvärderare och optimerare förbättrar träffsäkerheten men fördubblar beräkningsbehovet.
4. Komplexitet: Sekventiella arbetsflöden är lättast att felsöka.

Steg 2: Välj grundmodell och ramverk för orkestrering

Grundtanken när du bygger agenter med Claude är enkel. SDK:et sköter loopen, verktyg och MCP avgör vad agenten kan göra, och Skills beskriver hur den ska göra det. Det ger en tydlig ansvarsfördelning.

Claude Agent SDK erbjuder en agentloop (samla kontext, anropa modellen, kör verktyget, mata tillbaka resultatet och upprepa) som kan programmeras i Python eller TypeScript. LangGraph ger mer kontroll. Där kan du definiera explicita noder för logiken och bygga strikta skyddsräcken som hindrar modellen från att göra oönskade verktygsanrop.

Orkestreringslagret ger nödvändiga skyddsräcken som håller agenterna till uppgiften. De kan hårdkodas med verktyg som LangGraph eller hanteras med grafiska verktyg som Cursor Automations. Utan orkestrering kan en agent fastna i en oändlig loop vid ett enda fel.

Säker hantering av inloggningsuppgifter är avgörande. Hårdkoda aldrig API-nycklar i systemprompten. I produktionssystem är det enda säkra sättet att tillföra dem vid körning via miljövariabler.

Vi föredrar LangGraph för komplex dirigering. Det tvingar dig att tänka igenom tillståndsövergångar. Claude SDK passar bättre för snabba prototyper och verktygstunga uppgifter som kräver täta iterationer.

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

Steg 3: Implementera verktyg, webbåtkomst och minneshantering

AI-agenter använder MCP (Model Context Protocol), CLI-verktyg och ramverk som LangChain för att få tillgång till verktyg. Att kunna bygga anpassade AI-agenter innebär också att kunna förankra dem i verkligheten. Deras kunskap behöver bygga på verkliga förhållanden och aktuella data.

Annars begränsas den till minneslagring och träningsdata.

Inbyggda hämtningsverktyg från företag som OpenAI och Anthropic ger bara begränsad webbåtkomst. Därför behövs särskilda verktyg för webbåtkomst, som Firecrawl. Att hämta rå HTML slösar med kontextutrymme och förvirrar modellen.

Firecrawl har tre huvudsakliga endpoints för webbåtkomst: /search (sökningar på webben i realtid), /scrape (hämtar webbplatser som strukturerade data eller Markdown) och /interact (öppnar en riktig webbläsare för att klicka på knappar och fylla i formulär).

Med Firecrawl ger en typisk sida ungefär 2,788 token i rensad Markdown i stället för 38,381 token i rå HTML. Firecrawl ger 94 procent färre indatatoken än om du hämtar rå HTML. Det förbättrar agentens prestanda direkt.

Webbsidors struktur kan ändras, och sidorna kan innehålla irrelevant navigering eller skript. Välj ett dokumenterat, strukturerat API när det finns och testa dataextraktionen mot representativa sidor och layoutändringar.

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()

Minne är nödvändigt för AI-system som körs länge, eftersom alla modeller har ett begränsat kontextfönster. När gränsen nås måste kontexten byggas upp på nytt. Ett kontextfönster kan till exempel rymma 200,000 token innan det återställs och kontexten behöver återskapas med hjälp av minnet.

Du måste lagra samtalshistorik och tillstånd i en extern databas. När kontextfönstret blir fullt hämtar du en sammanfattning och relevanta fakta. Sedan bygger du upp prompten på nytt. Utgå aldrig från att modellen minns något utöver det den har fått i sin aktuella indata.

Hur hanterar du kostnader, API-nycklar och testning?

Om du kör fem agenter samtidigt betalar du för fem modellanrop på en gång. Enskilda agenter kostar mindre per körning men tar betydligt längre tid att bli klara. Du behöver väga snabbhet mot budget.

Ta en supportagent med medelhög volym som exempel: 10,000 körningar per månad, där manuell hantering kostar $5 per ärende, totalt $50,000. Kostnaden för automatisering ser annorlunda ut.

Driften kostar $100. Du når lönsamhet nästan omedelbart. Det är nödvändigt att testa koden runt agenten: simulera verktygsfel och testa timeoutlogiken grundligt innan du driftsätter något.

Vi använder deterministiska testfall för koden runt agenten och probabilistiska utvärderingar för modellen. Vi driftsätter aldrig en agent utan att testa hur den återhämtar sig från fel. Sluta fylla systempromptar med onödiga instruktioner.

Agent Skills är mappar med en SKILL.md-fil som lär agenten specialiserade arbetsuppgifter. De läses in vid behov, så att kontextfönstret inte fylls i onödan. Om du vill lära dig att bygga anpassade AI-agenter behöver du hålla isär systemets olika delar.

En mindre uppenbar insikt: Därför hör arbetsinstruktioner hemma i Skills

Det finns ett tydligt sätt att förstå hur agenter byggs med Claude: SDK:et driver loopen, verktyg och MCP avgör vad agenten kan göra, och Skills beskriver hur den ska göra det. Verktygen är handlingarna, Skills är handböckerna. Om du lägger alla instruktioner i systemprompten slösar du kontextutrymme, eftersom modellen läser instruktioner den inte behöver för den aktuella uppgiften.

Stegvis inläsning löser det. Agenten läser bara in SKILL.md-filen när den behöver utföra just den uppgiften. Det håller kontextfönstret fokuserat och minskar risken för hallucinationer.

Agenterna blir också modulära: du kan uppdatera en Skill utan att ändra den centrala orkestreringslogiken.