1 
2Claude 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.
3 
4I 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.
5 
6## Arkitektur
7 
8SDK'en foelger en simpel loop: **indsaml kontekst, handl, verificer, gentag**.
9 
10```mermaid
11graph TD
12    Input[User Prompt] --> Loop[Agent Loop]
13    Loop --> Reason[Claude Reasons]
14    Reason --> Tool[Call Tool]
15    Tool --> Result[Tool Result]
16    Result --> Loop
17    Reason --> Done[Final Response]
18 
19    subgraph "Built-in Tools"
20        T1[Read / Write / Edit]
21        T2[Bash / Terminal]
22        T3[Glob / Grep]
23        T4[WebSearch / WebFetch]
24    end
25 
26    subgraph "Custom Tools via MCP"
27        M1[Your API]
28        M2[Database]
29        M3[Slack / GitHub / etc.]
30    end
31 
32    Tool --> T1
33    Tool --> M1
34```
35 
36Det 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.
37 
38## Kom i gang
39 
40### Installation
41 
42```bash
43# TypeScript
44npm install @anthropic-ai/claude-agent-sdk
45 
46# Python
47pip install claude-agent-sdk
48```
49 
50Du skal bruge en Anthropic API-noegle sat som `ANTHROPIC_API_KEY` i dit miljoevariabel.
51 
52### Din foerste agent
53 
54```typescript
55import { query } from "@anthropic-ai/claude-agent-sdk";
56 
57const conversation = query({
58  prompt: "Find all TODO comments in the codebase and create a summary",
59  options: {
60    allowedTools: ["Read", "Glob", "Grep"],
61  },
62});
63 
64for await (const message of conversation) {
65  if (message.type === "assistant") {
66    process.stdout.write(message.content);
67  }
68  if (message.type === "result" && message.subtype === "success") {
69    console.log("\nDone:", message.result);
70  }
71}
72```
73 
74Det 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.
75 
76### Python-aequivalent
77 
78```python
79from claude_agent_sdk import query
80 
81async for message in query(
82    prompt="Find all TODO comments in the codebase and create a summary",
83    options={"allowed_tools": ["Read", "Glob", "Grep"]},
84):
85    if message.type == "assistant":
86        print(message.content, end="")
87    if message.type == "result" and message.subtype == "success":
88        print(f"\nDone: {message.result}")
89```
90 
91## Indbyggede vaerktoej
92 
93SDK'en leveres med de samme vaerktoej, der er tilgaengelige i Claude Code:
94 
95| Vaerktoej | Beskrivelse |
96|------|-------------|
97| **Read** | Laese filindhold |
98| **Write** | Oprette nye filer |
99| **Edit** | Lave maalrettede aendringer i eksisterende filer |
100| **Bash** | Koere shell-kommandoer |
101| **Glob** | Finde filer efter moenster |
102| **Grep** | Soege i filindhold med regex |
103| **WebSearch** | Soege pa nettet |
104| **WebFetch** | Hente en URL og returnere dens indhold |
105| **AskUserQuestion** | Bede brugeren om input |
106 
107Du styrer via `allowedTools`, hvilke vaerktoej agenten ma bruge. Hvis et vaerktoej ikke er pa listen, kan agenten ikke kalde det.
108 
109## Tilladelsestilstande
110 
111Da agenter koerer rigtige kommandoer pa rigtige systemer, er tilladelser vigtige.
112 
113| Tilstand | Adfaerd | Anvendelse |
114|------|----------|----------|
115| `default` | Tilpasset `canUseTool`-callback afgoer per kald | Finkornet kontrol |
116| `acceptEdits` | Godkend filoperationer automatisk, spoerg ved Bash | Udviklingsworkflows |
117| `dontAsk` | Afvis alt der ikke er i allowedTools | Begraensede agenter |
118| `bypassPermissions` | Godkend alt automatisk | Betroede sandbox-miljoeer |
119| `auto` | Model-klassificerer afgoer sikkerhed | Balanceret automatisering |
120 
121```typescript
122const conversation = query({
123  prompt: "Refactor the auth module to use JWT",
124  options: {
125    allowedTools: ["Read", "Edit", "Glob", "Grep", "Bash"],
126    permissionMode: "acceptEdits",
127  },
128});
129```
130 
131Til 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.
132 
133## Byg custom tools med MCP
134 
135Den 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.
136 
137### Eksempel: Vejr-tool
138 
139```typescript
140import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
141import { z } from "zod";
142 
143const getTemperature = tool(
144  "get_temperature",
145  "Get the current temperature at a location",
146  {
147    latitude: z.number().describe("Latitude"),
148    longitude: z.number().describe("Longitude"),
149  },
150  async ({ latitude, longitude }) => {
151    const res = await fetch(
152      `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m&temperature_unit=celsius`
153    );
154    const data = await res.json();
155    return {
156      content: [
157        {
158          type: "text",
159          text: `Current temperature: ${data.current.temperature_2m}C`,
160        },
161      ],
162    };
163  }
164);
165 
166const weatherServer = createSdkMcpServer({
167  name: "weather",
168  version: "1.0.0",
169  tools: [getTemperature],
170});
171 
172for await (const message of query({
173  prompt: "What's the weather like in Rome?",
174  options: {
175    mcpServers: { weather: weatherServer },
176    allowedTools: ["mcp__weather__get_temperature"],
177  },
178})) {
179  if (message.type === "result" && message.subtype === "success") {
180    console.log(message.result);
181  }
182}
183```
184 
185Custom tools foelger navnekonventionen `mcp__{server_name}__{tool_name}`. Du kan bruge wildcards i `allowedTools`: `"mcp__weather__*"` tillader alle vaerktoej fra vejr-serveren.
186 
187### Eksempel: Database-query-tool
188 
189```typescript
190const queryDb = tool(
191  "query_database",
192  "Run a read-only SQL query against the application database",
193  {
194    sql: z.string().describe("SQL SELECT query to execute"),
195  },
196  async ({ sql }) => {
197    // Validate: only allow SELECT queries
198    if (!sql.trim().toUpperCase().startsWith("SELECT")) {
199      return {
200        content: [{ type: "text", text: "Error: Only SELECT queries are allowed." }],
201      };
202    }
203 
204    const result = await pool.query(sql);
205    return {
206      content: [
207        {
208          type: "text",
209          text: JSON.stringify(result.rows, null, 2),
210        },
211      ],
212    };
213  }
214);
215```
216 
217## Tilslut eksterne MCP-servere
218 
219Ud 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.
220 
221```typescript
222for await (const message of query({
223  prompt: "Check the latest issues in the frontend repo and summarize them",
224  options: {
225    mcpServers: {
226      github: {
227        command: "npx",
228        args: ["-y", "@modelcontextprotocol/server-github"],
229        env: { GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_TOKEN },
230      },
231    },
232    allowedTools: ["mcp__github__*"],
233  },
234})) {
235  // ...
236}
237```
238 
239Du kan kombinere flere MCP-servere. Agenten ser alle vaerktoej fra alle tilsluttede servere og bruger dem efter behov.
240 
241```mermaid
242graph LR
243    Agent[Your Agent] --> SDK[Agent SDK]
244    SDK --> InProcess[In-process MCP\nCustom Tools]
245    SDK --> GitHub[GitHub MCP Server]
246    SDK --> Postgres[PostgreSQL MCP Server]
247    SDK --> Slack[Slack MCP Server]
248```
249 
250## Multi-agent-orkestrering
251 
252Til 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.
253 
254```typescript
255for await (const message of query({
256  prompt: "Review the PR, check for security issues, and update the changelog",
257  options: {
258    allowedTools: ["Read", "Edit", "Bash", "Glob", "Grep", "Agent"],
259    agents: [
260      {
261        name: "security-reviewer",
262        description: "Reviews code for security vulnerabilities",
263        prompt: "You are a security expert. Analyze code for OWASP Top 10 vulnerabilities.",
264        allowedTools: ["Read", "Glob", "Grep"],
265      },
266      {
267        name: "changelog-writer",
268        description: "Updates the CHANGELOG.md file based on recent changes",
269        prompt: "You maintain the project changelog. Follow Keep a Changelog format.",
270        allowedTools: ["Read", "Edit", "Bash"],
271      },
272    ],
273  },
274})) {
275  // The parent agent will:
276  // 1. Read the PR diff
277  // 2. Delegate security review to security-reviewer
278  // 3. Delegate changelog update to changelog-writer
279  // 4. Synthesize results
280}
281```
282 
283Tilfoj `"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.
284 
285```mermaid
286graph TD
287    Parent[Parent Agent] --> SR[Security Reviewer\nRead, Glob, Grep]
288    Parent --> CW[Changelog Writer\nRead, Edit, Bash]
289    SR --> Report[Security Report]
290    CW --> Updated[Updated CHANGELOG]
291    Report --> Parent
292    Updated --> Parent
293    Parent --> Final[Final Summary]
294```
295 
296## Sessioner og kontinuitet
297 
298Agenter 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.
299 
300```typescript
301let sessionId: string | undefined;
302 
303// First query
304for await (const message of query({
305  prompt: "Read the project structure and understand the architecture",
306  options: { allowedTools: ["Read", "Glob", "Grep"] },
307})) {
308  if (message.type === "init") {
309    sessionId = message.session_id;
310  }
311}
312 
313// Follow-up query (same session, full context preserved)
314for await (const message of query({
315  prompt: "Now refactor the auth module based on what you learned",
316  resume: sessionId,
317  options: { allowedTools: ["Read", "Edit", "Bash"] },
318})) {
319  // Agent remembers the full project context from the first query
320}
321```
322 
323## Claude Managed Agents
324 
325Hvis 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.
326 
327```mermaid
328graph LR
329    subgraph "Self-hosted (Agent SDK)"
330        Code[Your Code] --> SDK2[Agent SDK]
331        SDK2 --> API[Claude API]
332        SDK2 --> Tools[Your Tools]
333    end
334 
335    subgraph "Managed Agents"
336        App[Your App] --> MAPI[Managed Agents API]
337        MAPI --> Container[Anthropic-hosted Container]
338        Container --> API2[Claude API]
339        Container --> Tools2[Tools in Container]
340    end
341```
342 
343Den 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.
344 
345**Priser:**
346- **Agent SDK**: kun standard Claude API-tokenpriser. Du star for hosting.
347- **Managed Agents**: tokenpriser plus $0,08 per sessionstime (faktureret per millisekund).
348 
349## Best practices til produktion
350 
351### 1. Koer altid i sandbox
352 
353Koer aldrig agenter med ubegraensede tilladelser pa en produktionsmaskine. Brug containere (Docker, Fly.io, Modal) eller sandbox-miljoeer (E2B, Vercel Sandbox).
354 
355### 2. Begraens vaerktoejsadgang
356 
357Foelg princippet om mindste privilegium. En agent der genererer rapporter, har ikke brug for `Bash` eller `Write`.
358 
359```typescript
360// Too permissive
361allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
362 
363// Better: only what's needed
364allowedTools: ["Read", "Glob", "Grep"]
365```
366 
367### 3. Brug hooks som sikkerhedsnet
368 
369Med hooks kan du opsnappe vaerktoejskald foer og efter koersel. Brug dem til logging, validering og rate limiting.
370 
371```typescript
372const conversation = query({
373  prompt: "Analyze the codebase",
374  options: {
375    allowedTools: ["Read", "Glob", "Grep"],
376    hooks: {
377      PreToolUse: async (toolName, input) => {
378        console.log(`Tool call: ${toolName}`, input);
379        // Return false to block the call
380        if (toolName === "Bash" && input.command.includes("rm")) {
381          return false;
382        }
383        return true;
384      },
385    },
386  },
387});
388```
389 
390### 4. Haandter fejl pa en god made
391 
392Agent-loopen kan producere fejl  -  vaerktoejsfejl, API-rate-limits, context-window-overflow. Tjek altid beskedtyper.
393 
394```typescript
395for await (const message of conversation) {
396  switch (message.type) {
397    case "assistant":
398      // Agent reasoning
399      break;
400    case "tool_use":
401      // Agent is calling a tool
402      break;
403    case "result":
404      if (message.subtype === "error") {
405        console.error("Agent failed:", message.error);
406      }
407      break;
408  }
409}
410```
411 
412### 5. Overvaag tokenforbrug
413 
414Agent-loops kan forbruge betydelige maengder tokens, saerligt med store kodebaser. SDK'en inkluderer automatisk kontekstkomprimering, men du boer stadig overvaage forbruget.
415 
416## Konklusion
417 
418Claude 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.
419 
420Start 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.
421 
422Agent-loopen er den samme, der driver Claude Code. Hvis den kan bygge software, kan dine agenter det ogsa.
423 
424> **Tjekliste for at komme i gang:**
425>
426> - [x] Installer SDK'en (`npm install @anthropic-ai/claude-agent-sdk`)
427> - [x] Saet `ANTHROPIC_API_KEY` i dit miljoevariabel
428> - [x] Byg en simpel agent med indbyggede vaerktoej (Read, Glob, Grep)
429> - [x] Tilfoj et custom tool via en in-process MCP-server
430> - [x] Tilslut en ekstern MCP-server (GitHub, PostgreSQL, etc.)
431> - [x] Implementer multi-agent-orkestrering med sub-agenter
432> - [x] Opsaet et sandbox-miljoe til produktion
433> - [x] Tilfoj hooks til logging og sikkerhedsnet
434