AI Agents in Production: Claude SDK vs Anthropic Agents API vs Ollama Local—Step-by-Step Tutorial

What Is an AI Agent Really (Beyond the Buzzwords)

In 2026, the line between chatbot and agent has blurred. A **chatbot** receives input, generates text, and stops. An **agent** does what a chatbot does, but adds:

• Planning loop: "What's my next step?" The agent breaks the problem into sub-tasks, decides which tool to use, observes the result, decides whether to iterate.
• Reactive tool use: the agent doesn't generate the result directly, but invokes tools (APIs, databases, file systems) and integrates responses into its reasoning.
• Long-term memory: the agent remembers past conversations, maintains state between invocations, learns from failures.
• Validation and safety: each step is subject to guardrails—token budgets, timeouts, refusal policies, audit trails.

Concrete example: a code review agent receives a PR diff. Instead of saying "looks good," the agent:

1. Parse the diff (tool: get_diff)
2. Run linter (tool: run_linter)
3. Analyze cyclomatic complexity (tool: analyze_complexity)
4. Observe that two tests fail → decide to suggest a fix (tool: generate_fix_suggestion)
5. Compose a structured comment on the PR (no tool, synthesize observations)

This iterative, goal-oriented flow is what distinguishes an agent from a sophisticated chatbot.

Comparing 3 Production-Ready Stacks

1. Claude SDK (Anthropic)—The Control Choice

Claude SDK is Anthropic's official TypeScript/Python wrapper. It offers direct access to Claude 3.5 Sonnet/Opus models with native support for tool use and structured outputs.

Key features:

• Tool use typing: define tools as JSON schemas; the SDK automatically marshals requests/responses.
• Computer use: the model can perform actions on screenshots (OCR + clicking)—unique among the three.
• Structured output: guarantees JSON conforming to schema, zero hallucination on format.
• Batch API (Beta): 50% discount for async jobs (submit 100 tasks, wait 24h for results).

Pricing: Claude 3.5 Sonnet = $3 per MTok input, $15 output (2026-04). For 1M input tokens + 500K output, cost ~$10.5. Economical among the three.

Code example—TypeScript:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// 1. Definisci tool registry
const tools: Anthropic.Tool[] = [
  {
    name: "get_diff",
    description: "Retrieve git diff for a PR",
    input_schema: {
      type: "object",
      properties: {
        pr_id: { type: "number", description: "Pull request ID" },
      },
      required: ["pr_id"],
    },
  },
  {
    name: "run_linter",
    description: "Run eslint/pylint on code",
    input_schema: {
      type: "object",
      properties: {
        code: { type: "string", description: "Code snippet to lint" },
        language: { type: "string", enum: ["js", "py", "java"] },
      },
      required: ["code", "language"],
    },
  },
];

// 2. Agent loop ReAct
async function codeReviewAgent(prId: number) {
  const messages: Anthropic.MessageParam[] = [
    {
      role: "user",
      content: `Review PR #${prId}. Check code quality, suggest improvements.`,
    },
  ];

  for (let step = 0; step < 10; step++) {
    // Max 10 iterations
    const response = await client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 4096,
      tools: tools,
      messages: messages,
    });

    // Aggiorna history con response
    messages.push({
      role: "assistant",
      content: response.content,
    });

    // Se l'agente è finito (no tool use), esci
    if (response.stop_reason === "end_turn") {
      console.log("Agent completed review:");
      console.log(
        response.content
          .filter((b) => b.type === "text")
          .map((b) => (b.type === "text" ? b.text : ""))
          .join("\n")
      );
      break;
    }

    // Processa tool use
    const toolUseBlocks = response.content.filter((b) => b.type === "tool_use");
    const toolResults: Anthropic.ToolResultBlockParam[] = [];

    for (const toolUse of toolUseBlocks) {
      if (toolUse.type !== "tool_use") continue;

      let result = "";
      if (toolUse.name === "get_diff") {
        // Mock: in produzione, fetch da GitHub API
        result = `@@ -1,5 +1,6 @@\nfunction add(a, b) {\n  return a + b + 1; // BUG: off-by-one\n}`;
      } else if (toolUse.name === "run_linter") {
        result = `Line 3: unused variable 'temp'`;
      }

      toolResults.push({
        type: "tool_result",
        tool_use_id: toolUse.id,
        content: result,
      });
    }

    // Feedback all'agente
    messages.push({
      role: "user",
      content: toolResults,
    });
  }
}

// 3. Invoca agent
codeReviewAgent(42);
  

Pros: full control, no cloud lock-in, easy debugging, Batch API for cost reduction.

Cons: you manage memory (where store conversation history?), no cloud state management, manual retry logic.

2. Anthropic Agents API (Beta 2026)—The Cloud-First Choice

Agents API is Anthropic's managed wrapper. You declare an agent and Anthropic manages the loop, memory, state, and sub-agents.

Features:

• Cloud-managed state: Anthropic maintains conversation history, no client-side storage.
• Spawn sub-agents: one agent can create tasks for other agents (parallelism).
• Sandboxed code execution: the agent can run Python/JavaScript in isolation (computer use simulation).
• Web/file/knowledge base integration: native access to external resources (beta).

Pricing: per-step, ~$0.10 per step (beta estimate, not official 2026 pricing). For 100 steps = $10, but cloud speed compensates.

API call example—Python:

import anthropic

client = anthropic.Anthropic(api_key="your-key")

# Crea agente sul cloud Anthropic
agent = client.agents.create(
    model="claude-3-5-sonnet-20241022",
    instructions="""You are a code review expert.
    When given a PR:
    1. Analyze the diff
    2. Run linter/complexity checks
    3. Provide structured feedback
    Keep feedback to 3-5 points max.""",
    tools=[
        {
            "type": "bash_execution",
            "name": "run_linter",
            "description": "Run linter on code snippet",
        }
    ],
)

# Spawn task (agent processes asynchronously)
task = client.agents.tasks.create(
    agent_id=agent.id,
    input="Review this PR: https://github.com/user/repo/pull/42",
)

# Poll for result
import time

for _ in range(10):
    task = client.agents.tasks.retrieve(agent_id=agent.id, task_id=task.id)
    if task.state == "completed":
        print("Review result:")
        print(task.result)
        break
    time.sleep(2)
  

Pros: automatic state persistence, parallel sub-agents, sandboxed code execution, Anthropic-managed infra (zero ops).

Cons: latency >2s (network), no offline mode, opaque pricing (beta), Anthropic API lock-in.

3. Ollama Local—The Privacy-Critical Choice

Ollama is an open-source runtime for local LLM models. Download models (llama3.1:70b, qwen2.5-coder:32b, gemma2:27b), run locally (GPU required: RTX 4090, A100, etc.), zero recurring costs.

Features:

• Tool calling: llama3.1 7b+ supports tool use via special JSON format.
• Zero latency: local inference, ~0.5s per token (8b) vs 1.2s cloud.
• On-premise data: no cloud exposure, simpler EU AI Act compliance.
• Local fine-tuning: you can adapt the model to your specific domain.

Cons: expensive hardware (GPU >$2000), latency 5–15s per token on large models (70b), ~50GB memory footprint.

Python example:

import json
import requests

# Ollama running locally (ollama serve)
OLLAMA_URL = "http://localhost:11434"

def ollama_tool_use(prompt: str, tools: list[dict]) -> dict:
    """Agent loop con Ollama + tool calling."""

    # Prepara tool schema in formato JSON
    tool_schema = json.dumps(tools, indent=2)
    full_prompt = f"""You are a code review agent.
Tools available:
{tool_schema}

When you need to use a tool, respond with JSON:
{{"tool": "tool_name", "args": {{"key": "value"}}}}

User request: {prompt}"""

    # Chiama Ollama
    response = requests.post(
        f"{OLLAMA_URL}/api/generate",
        json={
            "model": "llama3.1:70b",
            "prompt": full_prompt,
            "stream": False,
        }
    )

    result = response.json()["response"]

    # Parse tool call (semplice, in produzione usa regex/JSON parser robusto)
    if "tool" in result and "args" in result:
        tool_call = json.loads(result[result.find("{"):result.rfind("}")+1])
        return tool_call

    return {"response": result}

# Invoca agent
review = ollama_tool_use(
    prompt="Review PR #42: https://github.com/...",
    tools=[
        {
            "name": "get_diff",
            "description": "Get git diff for PR",
            "parameters": {"type": "object", "properties": {"pr_id": {"type": "integer"}}}
        }
    ]
)
print(review)
  

Pros: zero recurring costs (post-hardware), on-prem privacy, no rate limits, absolute control.

Cons: prohibitive hardware, 10x cloud latency (70b), lower quality vs Claude (especially tool use, 3x higher hallucination rate).

Comparison Table—Technical Metrics

Verdict: for the vast majority of 2026 applications, Claude SDK is the optimal choice: low cost, acceptable latency, superior quality, maximum control. Agents API for MVPs with tight timelines (no DevOps). Ollama only if privacy is P0 and hardware is available.

Step-by-Step Tutorial: Build a Code Review Agent

Step 1—Project Setup (15 min)

Create a project folder and install dependencies.

# Setup Node.js project
mkdir agent-code-review
cd agent-code-review
npm init -y
npm install @anthropic-ai/sdk dotenv

# Crea .env
echo "ANTHROPIC_API_KEY=sk-..." > .env

# Verifica SDK
node -e "console.log(require('@anthropic-ai/sdk'))"
  

If you use Python:

mkdir agent-code-review && cd agent-code-review
python -m venv venv && source venv/bin/activate
pip install anthropic python-dotenv httpx

echo "ANTHROPIC_API_KEY=sk-..." > .env
  

Step 2—Define Tool Schema (20 min)

Specify 3 tools: get_diff, run_linter, analyze_complexity. Each tool has input schema and mock implementation.

// tools.ts
export interface Tool {
  name: string;
  description: string;
  input_schema: {
    type: string;
    properties: Record;
    required: string[];
  };
}

export const TOOLS: Tool[] = [
  {
    name: "get_diff",
    description: "Retrieve git diff for a GitHub pull request",
    input_schema: {
      type: "object",
      properties: {
        repo: {
          type: "string",
          description: "GitHub repo in format owner/repo",
        },
        pr_number: { type: "integer", description: "PR number" },
      },
      required: ["repo", "pr_number"],
    },
  },
  {
    name: "run_linter",
    description: "Run ESLint on JavaScript code",
    input_schema: {
      type: "object",
      properties: {
        code: { type: "string", description: "JavaScript code to lint" },
        config: {
          type: "string",
          description: "Linter config (airbnb, google, standard)",
          enum: ["airbnb", "google", "standard"],
        },
      },
      required: ["code", "config"],
    },
  },
  {
    name: "analyze_complexity",
    description: "Analyze cyclomatic complexity of a function",
    input_schema: {
      type: "object",
      properties: {
        code: { type: "string", description: "Function code" },
      },
      required: ["code"],
    },
  },
];

export async function executeTool(
  name: string,
  input: Record
): Promise {
  if (name === "get_diff") {
    // Mock GitHub API call
    return `
@@ -1,10 +1,12 @@
 export function calculateTotal(items: any[]) {
   let sum = 0;
   for (let i = 0; i < items.length; i++) {
-    sum += items[i].price; // ⚠️ No null check
+    sum += items[i]?.price ?? 0;
   }
   return sum;
 }
+
+// New: Helper function
+function formatPrice(price: number): string {
+  return new Intl.NumberFormat('en-US').format(price);
+}
    `;
  } else if (name === "run_linter") {
    return `
eslint results for config=${input.config}:
  Line 5: 'sum' is assigned value but never used (no-unused-vars)
  Line 7: Function too long, consider extracting (max-lines-per-function)
✓ 2 errors, 0 warnings
    `;
  } else if (name === "analyze_complexity") {
    return `
Cyclomatic complexity: 3
Cognitive complexity: 4
Max depth: 2
Recommendation: complexity is acceptable (target < 5)
    `;
  }
  return "Unknown tool";
}
  

Step 3—Implement ReAct Loop (25 min)

The agent's heart: ask → observe → decide → iterate.

import Anthropic from "@anthropic-ai/sdk";
import { executeTool, TOOLS } from "./tools";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function runCodeReviewAgent(prUrl: string, maxSteps: number = 10) {
  console.log(`🚀 Starting code review agent for ${prUrl}`);

  const messages: Anthropic.MessageParam[] = [
    {
      role: "user",
      content: `Review the following PR: ${prUrl}

      Provide a structured review with:
      1. Overall assessment
      2. Critical issues (bugs, security)
      3. Improvement suggestions
      4. Complexity analysis
      5. Recommendation (approve/request changes)`,
    },
  ];

  for (let step = 0; step < maxSteps; step++) {
    console.log(`\n--- Step ${step + 1}/${maxSteps} ---`);

    const response = await client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 2048,
      tools: TOOLS as any,
      messages: messages,
    });

    // Aggiungi response alla history
    messages.push({
      role: "assistant",
      content: response.content,
    });

    // Verifica se agente ha finito
    if (response.stop_reason === "end_turn") {
      const textBlock = response.content.find((c) => c.type === "text");
      if (textBlock && textBlock.type === "text") {
        console.log(`\n✅ Review Complete:\n${textBlock.text}`);
      }
      return;
    }

    // Processa tool use
    const toolUseBlocks = response.content.filter((c) => c.type === "tool_use");
    if (toolUseBlocks.length === 0) {
      // No tool, agente ha scritto testo ma non finito (stop_reason != end_turn)
      // Continua loop
      continue;
    }

    const toolResults: Anthropic.ToolResultBlockParam[] = [];

    for (const toolUse of toolUseBlocks) {
      if (toolUse.type !== "tool_use") continue;

      console.log(`📍 Tool: ${toolUse.name}`);
      console.log(`   Input: ${JSON.stringify(toolUse.input)}`);

      const result = await executeTool(toolUse.name, toolUse.input);
      console.log(`   Result: ${result.substring(0, 100)}...`);

      toolResults.push({
        type: "tool_result",
        tool_use_id: toolUse.id,
        content: result,
      });
    }

    // Feedback all'agente
    messages.push({
      role: "user",
      content: toolResults,
    });
  }

  console.log("⚠️ Max steps reached");
}

// Invoca agente
runCodeReviewAgent("https://github.com/user/repo/pull/42");
  

Step 4—Add Memory + Caching (20 min)

Persist conversations in Redis to avoid recalculation.

import * as redis from "redis";

const redisClient = redis.createClient();

interface AgentMemory {
  conversationId: string;
  messages: Anthropic.MessageParam[];
  createdAt: number;
  expiresAt: number; // 24h TTL
}

async function loadMemory(conversationId: string): Promise {
  const cached = await redisClient.get(`agent:${conversationId}`);
  if (!cached) return null;
  return JSON.parse(cached);
}

async function saveMemory(memory: AgentMemory): Promise {
  const ttl = 86400; // 24 hours
  await redisClient.setEx(
    `agent:${memory.conversationId}`,
    ttl,
    JSON.stringify(memory)
  );
}

async function runCodeReviewAgentWithMemory(
  prUrl: string,
  conversationId: string
) {
  // Carica memoria precedente
  let memory = await loadMemory(conversationId);

  if (!memory) {
    memory = {
      conversationId,
      messages: [
        {
          role: "user",
          content: `Review PR: ${prUrl}`,
        },
      ],
      createdAt: Date.now(),
      expiresAt: Date.now() + 86400000,
    };
  }

  // ... esegui loop ReAct usando memory.messages ...

  // Salva aggiornamenti
  await saveMemory(memory);
}
  

Step 5—Safety Guardrails (20 min)

Input sanitization, output filtering, budget limit, audit log.

interface SafetyConfig {
  maxTokensPerCall: number;
  maxTokensTotal: number;
  maxSteps: number;
  allowedTools: string[];
  auditLog: boolean;
}

const SAFETY_CONFIG: SafetyConfig = {
  maxTokensPerCall: 4096,
  maxTokensTotal: 10000,
  maxSteps: 10,
  allowedTools: ["get_diff", "run_linter", "analyze_complexity"],
  auditLog: true,
};

class SafeAgent {
  private tokenUsage: number = 0;
  private auditLog: any[] = [];

  async validateInput(input: string): Promise {
    // Detect prompt injection attempts
    const injectionPatterns = [
      /ignore previous instruction/i,
      /do not apply rule/i,
      /bypass safety/i,
    ];

    for (const pattern of injectionPatterns) {
      if (pattern.test(input)) {
        console.warn(`⚠️ Potential prompt injection detected`);
        return false;
      }
    }

    // Check input length
    if (input.length > 50000) {
      console.warn("⚠️ Input too large");
      return false;
    }

    return true;
  }

  async validateToolCall(
    toolName: string,
    input: Record
  ): Promise {
    // Check tool is in allowlist
    if (!SAFETY_CONFIG.allowedTools.includes(toolName)) {
      console.warn(`❌ Tool '${toolName}' not allowed`);
      return false;
    }

    // Type validation per tool
    if (toolName === "get_diff") {
      if (
        typeof input.repo !== "string" ||
        typeof input.pr_number !== "number"
      ) {
        return false;
      }
    }

    this.auditLog.push({
      timestamp: new Date().toISOString(),
      event: "tool_call",
      tool: toolName,
      input: JSON.stringify(input),
    });

    return true;
  }

  async checkBudget(tokensUsed: number): Promise {
    this.tokenUsage += tokensUsed;
    if (this.tokenUsage > SAFETY_CONFIG.maxTokensTotal) {
      console.warn(
        `❌ Budget exceeded: ${this.tokenUsage}/${SAFETY_CONFIG.maxTokensTotal}`
      );
      return false;
    }
    return true;
  }

  getAuditLog() {
    return this.auditLog;
  }
}
  

Step 6—Deploy + Monitor (30 min)

Systemd service + Prometheus metrics + health checks.

# Systemd service: /etc/systemd/system/agent-code-review.service
[Unit]
Description=Code Review Agent
After=network.target

[Service]
Type=simple
User=agent
WorkingDirectory=/opt/agent-code-review
ExecStart=/usr/bin/node dist/index.js
Restart=always
RestartSec=10

Environment="ANTHROPIC_API_KEY=sk-..."
Environment="REDIS_URL=redis://localhost:6379"
Environment="LOG_LEVEL=info"

# Resource limits
MemoryLimit=512M
CPUQuota=100%

# Security
NoNewPrivileges=true
ProtectSystem=strict
PrivateTmp=true

[Install]
WantedBy=multi-user.target
  

Prometheus metrics:

import prom from "prom-client";

const agentCounter = new prom.Counter({
  name: "agent_reviews_total",
  help: "Total code reviews completed",
  labelNames: ["status", "pr_repo"],
});

const toolCallCounter = new prom.Counter({
  name: "agent_tool_calls_total",
  help: "Tool invocations",
  labelNames: ["tool_name"],
});

const tokenGauge = new prom.Gauge({
  name: "agent_tokens_used",
  help: "Tokens consumed this session",
});

// Log metrica
agentCounter.labels("success", "user/repo").inc();
toolCallCounter.labels("get_diff").inc();
tokenGauge.set(2500);

// Prometheus scrape endpoint
app.get("/metrics", async (req, res) => {
  res.set("Content-Type", prom.register.contentType);
  res.end(await prom.register.metrics());
});
  

Anti-Patterns—5 Common Pitfalls

1. Infinite Loop Without max_steps

The agent calls tools, observes results, decides to iterate infinitely. In production, missing max_steps costs $$$.

// ❌ WRONG
while (true) {
  // agent loop senza break condition
}

// ✅ RIGHT
for (let step = 0; step < MAX_STEPS; step++) {
  if (response.stop_reason === "end_turn") break;
}
  

2. Untyped Tool Calling

Pass tools as strings, the agent hallucinates. E.g., "run_linter" with input `{code: 123}` (number instead of string).

// ❌ WRONG
const tools = [{ name: "run_linter", description: "..." }]; // NO schema

// ✅ RIGHT
const tools = [
  {
    name: "run_linter",
    input_schema: {
      type: "object",
      properties: {
        code: { type: "string" },
      },
      required: ["code"],
    },
  },
];
  

3. No Retry Logic on Rate Limit

API returns 429 (too many requests), agent fails. You must implement exponential backoff.

// ✅ RIGHT - exponential backoff
async function callClaudeWithRetry(
  messages: any[],
  maxRetries: number = 3
) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.messages.create({ messages, /* ... */ });
    } catch (error: any) {
      if (error.status === 429) {
        const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
        console.log(`Rate limited, retry in ${delay}ms`);
        await new Promise((r) => setTimeout(r, delay));
      } else {
        throw error;
      }
    }
  }
}
  

4. Memory Leak (Infinite History)

Conversation history grows unbounded → OOM. Implement context window rotation.

// ✅ RIGHT - keep only last N messages
function rotateContext(messages: any[], maxMessages: number = 20) {
  if (messages.length > maxMessages) {
    // Compatta messaggi vecchi in un sommario
    const oldMessages = messages.slice(0, -maxMessages);
    const summary = `Previous context: ${oldMessages.length} messages exchanged. Key decisions: [summarize].`;

    return [{ role: "user", content: summary }, ...messages.slice(-maxMessages)];
  }
  return messages;
}
  

5. Sensitive Logging (Tokens, PII)

Log entire messages in plaintext → Sensitive data exposed. Mask PII.

// ✅ RIGHT
function maskSensitive(text: string): string {
  return text
    .replace(/api[_-]?key[:\s]*[\w-]+/gi, "api_key:***")
    .replace(/email[:\s]*[\w\.\-@]+/gi, "email:***")
    .replace(/\d{3}-\d{2}-\d{4}/g, "SSN:***");
}

console.log("Agent input:", maskSensitive(userMessage));
  

FAQ—8 Critical Questions

Q1: When Should I Prefer Agent vs Simple Chatbot?

A: Agent when the task requires iteration and tool use. Examples: code review (iterate over diff → linter → complexity), data analysis (query database → filter → chart), tier-1 customer support (lookup database → policy check → respond). Chatbot suffices for FAQs, content generation, chat engagement.

Q2: Is 12–15s Latency with Ollama 70b Acceptable?

A: It depends on context. For batch (nightly jobs, weekly reports): yes. For real-time (webhook PR, API call): no (SLA timeout). Rule of thumb: if latency > 5s, consider Claude SDK or Agents API.

Q3: How Do I Measure Agent ROI in Production?

A: Key metrics: (1) Mean time to resolution (MTTR) before/after, (2) Human escalation rate (goal <5%), (3) Accuracy (correct decision, measured via human review), (4) Cost per decision = API cost / decisions processed. Example: code review agent costs $0.05/PR, human costs 15 min ($5), ROI = 100x.

Q4: Can I Fine-Tune Llama 3.1 for My Specific Domain?

A: Yes, but with costs: ~$500 GPU time + 500-example dataset preparation. Worth only if volume >100 inference/day. For niche domains (proprietary code, custom terminology), consider LoRA fine-tuning (~2 hours, $50).

Q5: EU AI Act Compliance for Agents: Is GP-AI Required?

A: If you use Claude SDK (Anthropic managed), compliance shifts to provider. If you use Ollama local, **you implement compliance**: risk assessment doc, bias testing, audit log, transparency notice ("this decision involves AI"). GP-AI registration required if system is "high-risk" (hiring, credit scoring, law enforcement).

Q6: Cost Projection: 10k Users/Month with Claude SDK?

A: Assume 100 token/user input, 200 output. 10k × 100 input + 10k × 200 output = 3M tokens. Cost = (3M/1M × $3) + (2M/1M × $15) = $39/day = $1,170/month. Agents API: ~$100/1000 step × 10k users = ~$1,000/month (beta, unofficial). Ollama: $0 recurring.

Q7: Difference Between MCP (Model Context Protocol) and Custom Tool Registry?

A: MCP (Anthropic standard) is an open protocol for exposing remote tools. Custom registry is local (JSON schema). MCP is for interoperability (one tool, many clients), custom for total control. Use MCP if you want Claude agent + Ollama agent simultaneously.

Q8: Best Practices for Agent A/B Testing (Variant Prompting)?

A: (1) Create 2 system prompt versions (e.g., "strict code reviewer" vs "lenient reviewer"), (2) Split traffic 50/50, (3) Gather metrics: accuracy (human audit sample 50 reviews each), speed (token count), cost. After 200 reviews, compare with statistical test (chi-square). Winners scale to 100%.

Resources + Authoritative Links

• Anthropic SDK Python GitHub—Official repository, complete examples
• Model Context Protocol (MCP) Spec—Anthropic standard for tool interop
• Ollama Model Library—Open-source model catalog (70b, 13b, 7b)
• LangChain Agents Documentation—Multi-model framework (Claude, Ollama, OpenAI)
• ReAct: Synergizing Reasoning and Acting (Yao et al., arXiv)—Foundational agent design paper
• OpenAI Function Calling Guide—Alternative reference (no tool use, but API call schema)
• Hugging Face Open-Source LLMs Guide—Best practices for training and deployment
• Anthropic Batch API Docs—Cost optimization for async jobs

Conclusion: Choose Your Stack

In 2026, no stack is "better" in absolute terms. It depends on context:

• Claude SDK: production default, SaaS, cost-conscious
• Agents API: quick MVPs, no infra overhead, latency/cost trade-off
• Ollama: privacy-critical, on-prem, when hardware available

The agent I described (code review) is archetypal: iteration + tool use + memory + safety. Apply the pattern to any domain: customer support (knowledge base lookup), data analysis (SQL query + visualization), recruitment (resume parsing + scoring).

The code is production-ready—add monitoring, structured logging, backup memory—and deploy on VPS/Kubernetes. The future is agents, not chatbots. Start today.

Want to dive deeper into AI Agents? Ebook coming Q4 2026: "AI Agents in Production: Complete Guide from Claude SDK to Enterprise Deployment"—25K words, 20 code examples, cost calculator, compliance checklist.