Byg AI-agenter med Claude Agent SDK: En praktisk guide

Claude Agent SDK giver dig programmatisk adgang til den samme agent loop, der driver Claude Code. Dine agenter kan laese filer, koere shell-kommandoer, soege pa nettet, redigere kode, kalde eksterne API'er via MCP-servere og orkestrere sub-agenter - alt sammen med fa linjer TypeScript eller Python.

I modsaetning til standard Anthropic Client SDK, hvor du bygger din egen tool loop, haandterer Agent SDK vaerktoejskoersel, kontekststyring, genforsog og orkestrering internt. Du beskriver hvad du vil, stiller vaerktoejerne til radighed, og agenten klarer resten.

Arkitektur

SDK'en foelger en simpel loop: indsaml kontekst, handl, verificer, gentag.

Det centrale indgangspunkt er query(), som returnerer en asynkron iterator, der streamer beskeder mens agenten arbejder. Hver besked fortaeller dig, hvad agenten laver: raesonnerer, kalder et vaerktoej, modtager et resultat eller leverer det endelige output.

Kom i gang

Installation

# TypeScript
npm install @anthropic-ai/claude-agent-sdk

# Python
pip install claude-agent-sdk

Du skal bruge en Anthropic API-noegle sat som ANTHROPIC_API_KEY i dit miljoevariabel.

Din foerste agent

import { query } from "@anthropic-ai/claude-agent-sdk";

const conversation = query({
  prompt: "Find all TODO comments in the codebase and create a summary",
  options: {
    allowedTools: ["Read", "Glob", "Grep"],
  },
});

for await (const message of conversation) {
  if (message.type === "assistant") {
    process.stdout.write(message.content);
  }
  if (message.type === "result" && message.subtype === "success") {
    console.log("\nDone:", message.result);
  }
}

Det er det hele. Agenten bruger Glob til at finde filer, Grep til at soege efter TODO-moenstre, Read til at inspicere resultater, og returnerer en struktureret opsummering. Du skriver ikke orkestreringslogikken - SDK'en klarer det.

Python-aequivalent

from claude_agent_sdk import query

async for message in query(
    prompt="Find all TODO comments in the codebase and create a summary",
    options={"allowed_tools": ["Read", "Glob", "Grep"]},
):
    if message.type == "assistant":
        print(message.content, end="")
    if message.type == "result" and message.subtype == "success":
        print(f"\nDone: {message.result}")

Indbyggede vaerktoej

SDK'en leveres med de samme vaerktoej, der er tilgaengelige i Claude Code:

Du styrer via allowedTools, hvilke vaerktoej agenten ma bruge. Hvis et vaerktoej ikke er pa listen, kan agenten ikke kalde det.

Tilladelsestilstande

Da agenter koerer rigtige kommandoer pa rigtige systemer, er tilladelser vigtige.

const conversation = query({
  prompt: "Refactor the auth module to use JWT",
  options: {
    allowedTools: ["Read", "Edit", "Glob", "Grep", "Bash"],
    permissionMode: "acceptEdits",
  },
});

Til produktionsbrug boer du altid koere agenter i sandbox-miljoeer (containere, VM'er) og bruge den mest restriktive tilladelsestilstand, der stadig lader agenten udfore sit arbejde.

Byg custom tools med MCP

Den virkelige styrke ved SDK'en ligger i at udvide agenter med dine egne vaerktoej. Custom tools defineres som in-process MCP-servere - ingen subproces-haandtering, ingen netvaerks-overhead.

Eksempel: Vejr-tool

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const getTemperature = tool(
  "get_temperature",
  "Get the current temperature at a location",
  {
    latitude: z.number().describe("Latitude"),
    longitude: z.number().describe("Longitude"),
  },
  async ({ latitude, longitude }) => {
    const res = await fetch(
      `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m&temperature_unit=celsius`
    );
    const data = await res.json();
    return {
      content: [
        {
          type: "text",
          text: `Current temperature: ${data.current.temperature_2m}C`,
        },
      ],
    };
  }
);

const weatherServer = createSdkMcpServer({
  name: "weather",
  version: "1.0.0",
  tools: [getTemperature],
});

for await (const message of query({
  prompt: "What's the weather like in Rome?",
  options: {
    mcpServers: { weather: weatherServer },
    allowedTools: ["mcp__weather__get_temperature"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Custom tools foelger navnekonventionen mcp__{server_name}__{tool_name}. Du kan bruge wildcards i allowedTools: "mcp__weather__*" tillader alle vaerktoej fra vejr-serveren.

Eksempel: Database-query-tool

const queryDb = tool(
  "query_database",
  "Run a read-only SQL query against the application database",
  {
    sql: z.string().describe("SQL SELECT query to execute"),
  },
  async ({ sql }) => {
    // Validate: only allow SELECT queries
    if (!sql.trim().toUpperCase().startsWith("SELECT")) {
      return {
        content: [{ type: "text", text: "Error: Only SELECT queries are allowed." }],
      };
    }

    const result = await pool.query(sql);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(result.rows, null, 2),
        },
      ],
    };
  }
);

Tilslut eksterne MCP-servere

Ud over in-process-vaerktoej kan du forbinde til enhver eksisterende MCP-server - de samme servere der fungerer med Claude Desktop, Cursor og andre MCP-klienter.

for await (const message of query({
  prompt: "Check the latest issues in the frontend repo and summarize them",
  options: {
    mcpServers: {
      github: {
        command: "npx",
        args: ["-y", "@modelcontextprotocol/server-github"],
        env: { GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_TOKEN },
      },
    },
    allowedTools: ["mcp__github__*"],
  },
})) {
  // ...
}

Du kan kombinere flere MCP-servere. Agenten ser alle vaerktoej fra alle tilsluttede servere og bruger dem efter behov.

Multi-agent-orkestrering

Til komplekse workflows kan du definere specialiserede sub-agenter, som den overordnede agent delegerer til. Hver sub-agent har sin egen prompt, sine egne vaerktoej og sit eget fokusomrade.

for await (const message of query({
  prompt: "Review the PR, check for security issues, and update the changelog",
  options: {
    allowedTools: ["Read", "Edit", "Bash", "Glob", "Grep", "Agent"],
    agents: [
      {
        name: "security-reviewer",
        description: "Reviews code for security vulnerabilities",
        prompt: "You are a security expert. Analyze code for OWASP Top 10 vulnerabilities.",
        allowedTools: ["Read", "Glob", "Grep"],
      },
      {
        name: "changelog-writer",
        description: "Updates the CHANGELOG.md file based on recent changes",
        prompt: "You maintain the project changelog. Follow Keep a Changelog format.",
        allowedTools: ["Read", "Edit", "Bash"],
      },
    ],
  },
})) {
  // The parent agent will:
  // 1. Read the PR diff
  // 2. Delegate security review to security-reviewer
  // 3. Delegate changelog update to changelog-writer
  // 4. Synthesize results
}

Tilfoj "Agent" til den overordnede agents allowedTools for at aktivere delegering. Sub-agenter koerer med deres egne vaerktoej og kan ikke tilga den overordnede agents vaerktoej, medmindre det udtrykkeligt tillades.

Sessioner og kontinuitet

Agenter kan bevare kontekst pa tvaers af flere foresp orgsler ved at bruge sessioner. Fang session_id fra den foerste interaktion og send den med i resume til efterfoelgende forespoergsler.

let sessionId: string | undefined;

// First query
for await (const message of query({
  prompt: "Read the project structure and understand the architecture",
  options: { allowedTools: ["Read", "Glob", "Grep"] },
})) {
  if (message.type === "init") {
    sessionId = message.session_id;
  }
}

// Follow-up query (same session, full context preserved)
for await (const message of query({
  prompt: "Now refactor the auth module based on what you learned",
  resume: sessionId,
  options: { allowedTools: ["Read", "Edit", "Bash"] },
})) {
  // Agent remembers the full project context from the first query
}

Claude Managed Agents

Hvis du ikke vil hoste agent-infrastrukturen selv, tilbyder Claude Managed Agents (lanceret i april 2026) en fuldt administreret cloud-tjeneste. Anthropic koerer containerne, haandterer skalering og stiller et streaming-API til radighed.

Den vigtigste forskel: med Agent SDK koerer du agent-loopen i din egen infrastruktur. Med Managed Agents hoster og koerer Anthropic agenten for dig. Du interagerer via et sessionsbaseret API og modtager events via Server-Sent Events.

Priser:

• Agent SDK: kun standard Claude API-tokenpriser. Du star for hosting.
• Managed Agents: tokenpriser plus $0,08 per sessionstime (faktureret per millisekund).

Best practices til produktion

1. Koer altid i sandbox

Koer aldrig agenter med ubegraensede tilladelser pa en produktionsmaskine. Brug containere (Docker, Fly.io, Modal) eller sandbox-miljoeer (E2B, Vercel Sandbox).

2. Begraens vaerktoejsadgang

Foelg princippet om mindste privilegium. En agent der genererer rapporter, har ikke brug for Bash eller Write.

// Too permissive
allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]

// Better: only what's needed
allowedTools: ["Read", "Glob", "Grep"]

3. Brug hooks som sikkerhedsnet

Med hooks kan du opsnappe vaerktoejskald foer og efter koersel. Brug dem til logging, validering og rate limiting.

const conversation = query({
  prompt: "Analyze the codebase",
  options: {
    allowedTools: ["Read", "Glob", "Grep"],
    hooks: {
      PreToolUse: async (toolName, input) => {
        console.log(`Tool call: ${toolName}`, input);
        // Return false to block the call
        if (toolName === "Bash" && input.command.includes("rm")) {
          return false;
        }
        return true;
      },
    },
  },
});

4. Haandter fejl pa en god made

Agent-loopen kan producere fejl - vaerktoejsfejl, API-rate-limits, context-window-overflow. Tjek altid beskedtyper.

for await (const message of conversation) {
  switch (message.type) {
    case "assistant":
      // Agent reasoning
      break;
    case "tool_use":
      // Agent is calling a tool
      break;
    case "result":
      if (message.subtype === "error") {
        console.error("Agent failed:", message.error);
      }
      break;
  }
}

5. Overvaag tokenforbrug

Agent-loops kan forbruge betydelige maengder tokens, saerligt med store kodebaser. SDK'en inkluderer automatisk kontekstkomprimering, men du boer stadig overvaage forbruget.

Konklusion

Claude Agent SDK forvandler en LLM fra en spoergsmal-svar-maskine til noget der minder mere om en junior-udvikler. Dine agenter kan laese, skrive, koere, verificere og iterere - det samme workflow som et menneske foelger.

Start i det sma: byg en agent med et par indbyggede vaerktoej. Tilfoj derefter custom MCP-tools til dit specifikke domane. Skaler op til multi-agent-orkestrering, nar dine workflows kraever specialisering.

Agent-loopen er den samme, der driver Claude Code. Hvis den kan bygge software, kan dine agenter det ogsa.

Tjekliste for at komme i gang:

• Installer SDK'en (npm install @anthropic-ai/claude-agent-sdk)
• Saet ANTHROPIC_API_KEY i dit miljoevariabel
• Byg en simpel agent med indbyggede vaerktoej (Read, Glob, Grep)
• Tilfoj et custom tool via en in-process MCP-server
• Tilslut en ekstern MCP-server (GitHub, PostgreSQL, etc.)
• Implementer multi-agent-orkestrering med sub-agenter
• Opsaet et sandbox-miljoe til produktion
• Tilfoj hooks til logging og sikkerhedsnet