1~
2Claude Agent SDK ger dig programmatisk tillgang till samma agent loop som driver Claude Code. Dina agenter kan laesa filer, koera shell-kommandon, soeka pa webben, redigera kod, anropa externa API:er via MCP-servrar och orkestrera sub-agenter  -  allt med nagra fa rader TypeScript eller Python.
3~
4Till skillnad fran standard Anthropic Client SDK, daer du bygger din egen tool loop, hanterar Agent SDK verktygskoerning, kontexthantering, omfoersoek och orkestrering internt. Du beskriver vad du vill, tillhandahaller verktygen, och agenten skoeter resten.
5~
6## Arkitektur
7~
8SDK:n foeljer en enkel loop: **samla kontext, agera, verifiera, upprepa**.
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~
36Den centrala ingangspunkten aer `query()`, som returnerar en asynkron iterator som streamar meddelanden medan agenten arbetar. Varje meddelande talar om vad agenten goer: resonerar, anropar ett verktyg, tar emot ett resultat eller levererar den slutgiltiga outputen.
37~
38## Komma igang
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 behoever en Anthropic API-nyckel satt som `ANTHROPIC_API_KEY` i din miljoevariabel.
51~
52### Din foersta 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 aer allt. Agenten anvaender Glob foer att hitta filer, Grep foer att soeka efter TODO-moenster, Read foer att inspektera traeffar, och returnerar en strukturerad sammanfattning. Du skriver inte orkestreringslogiken  -  SDK:n hanterar det.
75~
76### Python-motsvarighet
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## Inbyggda verktyg
92~
93SDK:n levereras med samma verktyg som finns tillgaengliga i Claude Code:
94~
95| Verktyg | Beskrivning |
96|------|-------------|
97| **Read** | Laesa filinnehall |
98| **Write** | Skapa nya filer |
99| **Edit** | Goera riktade aendringar i befintliga filer |
100| **Bash** | Koera shell-kommandon |
101| **Glob** | Hitta filer efter moenster |
102| **Grep** | Soeka i filinnehall med regex |
103| **WebSearch** | Soeka pa webben |
104| **WebFetch** | Haemta en URL och returnera dess innehall |
105| **AskUserQuestion** | Be anvaendaren om inmatning |
106~
107Du styr vilka verktyg agenten far anvaenda via `allowedTools`. Om ett verktyg inte finns i listan kan agenten inte anropa det.
108~
109## Behoerrighetslaegen
110~
111Eftersom agenter koer riktiga kommandon pa riktiga system aer behoerrigheter viktiga.
112~
113| Laege | Beteende | Anvaendningsfall |
114|------|----------|----------|
115| `default` | Anpassad `canUseTool`-callback avgoeravid varje anrop | Detaljerad kontroll |
116| `acceptEdits` | Godkaenn filoperationer automatiskt, fraga vid Bash | Utvecklingsworkflows |
117| `dontAsk` | Neka allt som inte finns i allowedTools | Begraensade agenter |
118| `bypassPermissions` | Godkaenn allt automatiskt | Betrodda sandbox-miljoeer |
119| `auto` | Modellklassificerare avgoeraer saekerhet | Balanserad 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~
131Foer produktionsanvaendning boeraer du alltid koera agenter i sandbox-miljoeer (containers, VM:ar) och anvaenda det mest restriktiva behoerrighetslaege som fortfarande later agenten goera sitt jobb.
132~
133## Bygga egna verktyg med MCP
134~
135Den verkliga styrkan hos SDK:n ligger i att utvidga agenter med egna verktyg. Egna verktyg definieras som in-process MCP-servrar  -  ingen subprocesshantering, ingen naetverks-overhead.
136~
137### Exempel: Vaeder-verktyg
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~
185Egna verktyg foeljer namnkonventionen `mcp__{server_name}__{tool_name}`. Du kan anvaenda wildcards i `allowedTools`: `"mcp__weather__*"` tillater alla verktyg fran vaeder-servern.
186~
187### Exempel: Databasfrageverktyg
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## Ansluta externa MCP-servrar
218~
219Utoevar in-process-verktyg kan du ansluta till vilken befintlig MCP-server som helst  -  samma servrar som fungerar med Claude Desktop, Cursor och andra 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 kombinera flera MCP-servrar. Agenten ser alla verktyg fran alla anslutna servrar och anvaender 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~
252Foer komplexa workflows kan du definiera specialiserade sub-agenter som den oeverordnade agenten delegerar till. Varje sub-agent har sin egen prompt, sina egna verktyg och sitt 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~
283Inkludera `"Agent"` i den oeverordnade agentens `allowedTools` foer att aktivera delegering. Sub-agenter koers med sina egna verktyg och kan inte komma at den oeverordnade agentens verktyg om det inte uttryckligen medges.
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 och kontinuitet
297~
298Agenter kan behaalla kontext oevar flera fragor genom att anvaenda sessioner. Fanga `session_id` fran den foersta interaktionen och skicka med den i `resume` foer efterfoeljande fragor.
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~
325Om du inte vill hosta agent-infrastrukturen sjaelv erbjuder **Claude Managed Agents** (lanserat i april 2026) en helt hanterad molntjaenst. Anthropic koer containrarna, skoeter skalningen och tillhandahaller ett streaming-API.
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 viktigaste skillnaden: med Agent SDK koer du agent-loopen i din egen infrastruktur. Med Managed Agents hostar och koer Anthropic agenten at dig. Du interagerar via ett sessionsbaserat API och tar emot events via Server-Sent Events.
344~
345**Priser:**
346- **Agent SDK**: enbart standardpriser foer Claude API-tokens. Du star foer hostingen.
347- **Managed Agents**: tokenpriser plus $0,08 per sessionstimme (faktureras per millisekund).
348~
349## Best practices foer produktion
350~
351### 1. Koer alltid i sandbox
352~
353Koer aldrig agenter med obegransade behoerrigheter pa en produktionsmaskin. Anvaend containers (Docker, Fly.io, Modal) eller sandbox-miljoeer (E2B, Vercel Sandbox).
354~
355### 2. Begraensa verktygsatkomst
356~
357Foelj principen om minsta behoerighet. En agent som genererar rapporter behoever varken `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. Anvaend hooks som skyddsraecken
368~
369Med hooks kan du fanga upp verktygsanrop foere och efter koerning. Anvaend dem foer loggning, validering och 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. Hantera fel pa ett bra saett
391~
392Agent-loopen kan producera fel  -  verktygsfel, API-rate-limits, context-window-overflow. Kontrollera alltid meddelandetyper.
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. Oevervaka tokenanvaendning
413~
414Agent-loopar kan foerbruka avsevarda maengder tokens, saerskilt med stora kodbaser. SDK:n inkluderar automatisk kontextkomprimering, men du boer aenda oevervaka anvaendningen.
415~
416## Slutsats
417~
418Claude Agent SDK foerandrar ett LLM fran en fraga-svar-maskin till nagot som liknar en junior-utvecklare. Dina agenter kan laesa, skriva, koera, verifiera och iterera  -  samma arbetsflode som en maenniska foeljer.
419~
420Boerja smatt: bygg en agent med nagra fa inbyggda verktyg. Laegg sedan till egna MCP-verktyg foer din specifika domaen. Skala upp till multi-agent-orkestrering naer dina workflows kraever specialisering.
421~
422Agent-loopen aer densamma som driver Claude Code. Om den kan bygga mjukvara kan dina agenter det ocksa.
423~
424> **Checklista foer att komma igang:**
425>
426> - [x] Installera SDK:n (`npm install @anthropic-ai/claude-agent-sdk`)
427> - [x] Saett `ANTHROPIC_API_KEY` i din miljoevariabel
428> - [x] Bygg en enkel agent med inbyggda verktyg (Read, Glob, Grep)
429> - [x] Laegg till ett eget verktyg via en in-process MCP-server
430> - [x] Anslut en extern MCP-server (GitHub, PostgreSQL, etc.)
431> - [x] Implementera multi-agent-orkestrering med sub-agenter
432> - [x] Saett upp en sandbox-miljoe foer produktion
433> - [x] Laegg till hooks foer loggning och skyddsraecken
434~