# Claude Agent SDK Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/claude-agent-sdk
> Markdown URL: https://aitinkerers.org/technologies/claude-agent-sdk.md
> Technology record last updated: 2026-02-23T01:04:03Z
> Generated: 2026-09-21T11:44:16Z

The Claude Agent SDK (Python, TypeScript) transforms Claude into an autonomous, production-ready agent by granting it controlled access to a computer: file operations, Bash execution, and external tool integration via the Model Context Protocol (MCP).

This SDK provides the core agent harness that powers Claude Code, enabling developers to build sophisticated, general-purpose agents. It offers official TypeScript and Python libraries for seamless integration. Agents gain powerful, safe capabilities: reading and writing files, executing sandboxed Bash commands, and leveraging a rich tool ecosystem. The framework includes essential production features (e.g., automatic context management, granular permission modes like `acceptEdits`, and built-in cost tracking). Use the open Model Context Protocol (MCP) to connect custom tools, databases, and APIs, extending Claude’s utility far beyond simple chat to complex, multi-step workflows.

- Official technology site: https://docs.claude.com/en/api/agent-sdk/overview
- Public AI Tinkerers demos and talks: 16
- Result page: 1 of 1

## Recent Public Talks and Demos

### [The loss curve lied: catching hidden safety drift inside the fine-tuning, automated with an agent!](https://zurich.aitinkerers.org/talks/rsvp_Vnt244xXFE0)

We built a fine-tuning where a Claude-Code based agent that helps founders and researchers fine-tune models on their datasets, and get more insights than just the training and eval losses. In particular, we also show the model’s regress on safety and general capability, metrics that otherwise would be overlooked. For example, we give it a medical instruction dataset; the agent asks a few multiple-choice questions and proposes concepts like "recommends unsafe or contraindicated actions," "downplays red-flag symptoms that need urgent care," and "implies clinical authority it doesn't have," then writes the run config. Then, for each concept, it fits a single direction in the model's activations (difference-of-means, following Persona Vectors, Chen et al. 2025, arXiv:2507.21509) that “encodes” that concept, and reads that direction off every checkpoint during LoRA training. Live we can show the agent conversation proposing the concepts, as how they drift alongside per-checkpoint evals. This is part of an ongoing research agenda with a collaboration of researchers from ETH Zurich, ETH AI Center and Agentic Systems Lab. We formulated our research into an agentic harness and live demo in an anthropic hackathon last week, and want to share more about it! Also, we imagine this as an open-source effort.

- Event context: AI Tinkerers Zürich: July Build Night with Swisscom Ventures — 2026-07-01 — Zürich
- Public talk page: https://zurich.aitinkerers.org/talks/rsvp_Vnt244xXFE0

### [Harness: A Multi-Agent Claude Orchestrator That Builds and QA's Games Autonomously](https://singapore.aitinkerers.org/talks/rsvp_RwBQJVJwoLk)

Harness is a game-agnostic multi-agent orchestrator that uses the Claude Agent SDK to autonomously build and test games end-to-end. It reads a feature-list.json from any target game project, spawns a role-specific generator agent (gameplay / UI-art / audio) to implement each feature with full tool access (Read, Write, Edit, Bash, Glob, Grep + Godot MCP), then spawns a separate evaluator agent that launches the game, classifies each test step as DATA / VISUAL / BOTH, captures screenshots, and emits pass/fail verdicts. A watchdog loop detects stuck sessions and a pre-flight smoke test validates tool permissions before real work begins. Everything streams live to a single-process Fastify + React dashboard over WebSockets — you watch agents ship and break features in real time. For the demo I'll drive Harness against a live Godot project, show the full loop (pick → implement → evaluate → retry), and walk through how session records, screenshots, and eval reports are persisted back to the target repo.

- Event context: AI Tinkerers Singapore: The Agentic Future & Dev/Eng Workflows — 2026-04-21 — Singapore
- Public talk page: https://singapore.aitinkerers.org/talks/rsvp_RwBQJVJwoLk

### [Autonomous background coding agents](https://houston.aitinkerers.org/talks/rsvp_oNQb0zIHFIE)

An implementation for an autonomous background coding agent to run long horizon tasks

- Event context: AI Tinkerers Houston: April Meetup — 2026-04-14 — Houston
- Public talk page: https://houston.aitinkerers.org/talks/rsvp_oNQb0zIHFIE

### [My own version of OpenClaw focused on 24x7 development](https://columbus.aitinkerers.org/talks/rsvp_nJf4Q-0QtQA)

I wanted an AI that builds and tests 24x7 and only pings me when it actually needs input. The Continuous Executive Coding Agent is the answer: a PM2-backed executive loop running Agent SDK workers that pulls from a priority queue, breaks goals into steps and contracts, retries with different strategies on failure, and escalates through Gmail or Discord only when truly stuck. Everything runs under an immutable constitution. It's evolved through three stages. First, the executive loop itself, with the goals/steps/contracts hierarchy and an identity layer for email-in, Discord-out. Second, multi-vendor parity, so workers run on Claude, Codex, or Kimi K2.5, selectable per goal. Third, harness integration, where my plan-then-build pipelines (generic, EDS, study) plug in as meta-workers or still run standalone from a unified CLI.

- Event context: AI Tinkerers - Columbus April Meetup — 2026-04-06 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_nJf4Q-0QtQA

### [Evaluation-Driven Skill Development](https://nyc.aitinkerers.org/talks/rsvp_kRiiAXuZymg)

Live demo of skillet, an open-source framework for developing Claude Code skills through evals. I'll walk the full loop: capture a failure as a YAML eval, run an evaluation baseline, generate a skill, then auto-tune it until it passes.

- Event context: March Demo Day, hosted by Flowglad — 2026-03-18 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_kRiiAXuZymg

### [Cloud-Hosted, Multi-Agent Workspaces (or: Gas Town in the Sky)](https://seattle.aitinkerers.org/talks/rsvp_mVgQoXtoVzE)

A live walkthrough of a multi-agent software development loop in the cloud: Head of Engineering (agent) receives a request from Discord, writes the code, opens a PR, goes to Head of Infra to deploy, and then finally hands the change to Head of QA for review and merge, all without any intervention from the user. The presentation will cover how I created the best way to make easy, configurable, multi-agent workspaces without the infrastructure hassle or security risks of self-hosted solutions. This includes setting up persistent, isolated workspaces, configurable prompts and variables, cross-agent messaging, and deep session analytics, all managed through a custom-built MCP server and my local Claude Code. In addition, throughout the demo I'll share exciting developments I've seen so far in terms of emergent behavior, cross-agent coordination, and workspace management.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — March 9th, 2026 — 2026-03-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_mVgQoXtoVzE

### [Orchestrating Claude Inside Vercel Sandboxes for an Isolated Commerce Environment](https://poland.aitinkerers.org/talks/rsvp_-g6_pJg01zE)

This talk walks through how we run Claude inside per-session Vercel Sandboxes to operate on a live Next.js commerce system. Each session provisions an isolated sandbox where Claude connects via the Claude Agent SDK over WebSockets. The initial prompt fetches a Git repository of the storefront, which becomes the working workspace. From there, Claude proposes structured mutations that are applied incrementally as diffs and commits, with optional deployment to Vercel. Commerce state (products, pricing, checkout) is never modified via arbitrary code edits. Instead, mutations flow through typed calls exposed by our Commerce SDK. UI changes can be generative; transactional operations must pass validated primitives. We’re evolving the system toward an in-memory project file representation to reduce cold starts and avoid long sandbox wakeups. Mutations are first applied to this in-memory graph, then executed via Just Bash inside the sandbox, enabling background transitions while keeping the live instance responsive. The demo focuses on the WebSocket orchestration loop, sandbox isolation boundaries, tool schema design, and the failure cases we encountered while ensuring the commerce system remains consistent and deployable at all times.

- Event context: AI Tinkerers Poland x Codex - Meetup in Warsaw #7 (4th March, Wednesday) — 2026-03-04 — Poland
- Public talk page: https://poland.aitinkerers.org/talks/rsvp_-g6_pJg01zE

### [Making claude code write more reliable code](https://seattle.aitinkerers.org/talks/rsvp_fdUsUhnb1F0)

LLMs keep getting better with every release but code reliability is still an issue. Coding agents dont reliably enforce user defined guardrails and/or completely bypass instructions. I'm presenting ATX (short for Agent Nexus) which is a tool that seamlessly integrates with existing claude code (using MCP) and provides real time feedback to claude code to improve its quality.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — February 9th, 2026 — 2026-02-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_fdUsUhnb1F0

### [Building a Cloud-Hosted AI Agent Sandbox with Claude Agent SDK](https://seattle.aitinkerers.org/talks/rsvp_ZYnsYVYcytM)

This presentation will cover the steps taken to build a GCP-hosted AI agent sandbox with support for the Claude Agent SDK. All deployment and configuration is done via API (MCP support coming soon) so users can deploy new agents and delegate tasks to be completed async. Since it's API accessible, this works with any coding agent to give your agents sub-agent superpowers!

- Event context: AI Tinkerers Seattle: January Meetup — 2026-01-31 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_ZYnsYVYcytM

### [How building with AI showed me where all the design decisions were hiding](https://dublin.aitinkerers.org/talks/rsvp_q0iiQiI9vwk)

I'm a product designer who can't code - but I've built an AI-powered SaaS platform using Claude Code, Codex, and Supabase. I'll walk through the actual implementation: agent orchestration, feedback loops, memory systems. Where I let AI apply judgement vs kept tight constraints. And the product decisions I didn't know existed until I owned the full build.

- Event context: AI Tinkerers Dublin Meetup — Baseline, January 26, 2026 — 2026-01-26 — Dublin
- Public talk page: https://dublin.aitinkerers.org/talks/rsvp_q0iiQiI9vwk

### [How I Built a Fake TechCrunch with Claude Code and the Claude Agent SDK](https://chicago.aitinkerers.org/talks/rsvp_dD8_3Wyp94U)

Given that TechCrunch seems to want to talk about every next project as the next world-changing technology, I decided to build a parody site where you can input your public GitHub repo and get a similar article "written" about your project. It uses the Claude Agent SDK to explore the repo and then generates the article on the fly. Featured images by Nano Banana and the whole thing was built using Claude Code. Article about how I built it: https://floorboardai.com/how-i-built-a-satirical-news-generator-with-claude-code/

- Event context: AI Tinkerers Chicago January Meetup ft. PostHog — 2026-01-20 — Chicago
- Public talk page: https://chicago.aitinkerers.org/talks/rsvp_dD8_3Wyp94U

### [FlowCoder: Visual agentic workflow customization for Claude Code and Codex](https://seattle.aitinkerers.org/talks/rsvp_U8IOqU3RbuE)

Long-time vibe coders encounter certain repeated frustrations with our favorite coding agents: they can fail to properly follow complex prompts, they often require repetitive prompting patterns, and their autonomous capabilities on long time scales (e.g. overnight) are limited. FlowCoder is an app designed to address these problems, allowing the user to create and execute custom automated workflows for Claude Code and Codex via a visual flowchart builder. This project aims to both help vibe coders scale their results and enable autonomous agent research by building on top of existing coding agents. FlowCoder's flowchart-based workflows are primarily directed graphs of prompts for agents, bash commands, and calls to execute other flowcharts. These directed graphs can contain branches and cycles, supporting both while-loop and for-loop paradigms, enabling powerful autonomous behaviors. These flowcharts support a number of programmatic features, including variable handling, branching based on boolean expressions, a stack of flowchart commands each with its own variable scope, and argument substitution. Git integration is built-in, with automatic git snapshots after each flowchart block. FlowCoder builds off existing coding agents rather than raw LLM APIs, allowing it to take advantage of intelligent behaviors already encoded in to Claude Code and Codex.

- Event context: The Holiday Science Fair (Hot Cocoa, Cookies, and Demos!) — 2025-12-19 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_U8IOqU3RbuE

### [FlowCoder: Visual agentic workflow customization for Claude Code and Codex](https://seattle.aitinkerers.org/talks/rsvp_Rlnac_dTZg4)

Long-time vibe coders encounter certain repeated frustrations with our favorite coding agents: they can fail to properly follow complex prompts, they often require repetitive prompting patterns, and their autonomous capabilities on long time scales (e.g. overnight) are limited. FlowCoder is an app designed to address these problems, allowing the user to create and execute custom automated workflows for Claude Code and Codex via a visual flowchart builder. This project aims to both help vibe coders scale their results and enable autonomous agent research by building on top of existing coding agents. FlowCoder's flowchart-based workflows are primarily directed graphs of prompts for agents, bash commands, and calls to execute other flowcharts. These directed graphs can contain branches and cycles, supporting both while-loop and for-loop paradigms, enabling powerful autonomous behaviors. These flowcharts support a number of programmatic features, including variable handling, branching based on boolean expressions, a stack of flowchart commands each with its own variable scope, and argument substitution. Git integration is built-in, with automatic git snapshots after each flowchart block. FlowCoder builds off existing coding agents rather than raw LLM APIs, allowing it to take advantage of intelligent behaviors already encoded in to Claude Code and Codex.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — December 8, 2025 — 2025-12-09 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_Rlnac_dTZg4

### [Using AI for Force Multiplication](https://toronto.aitinkerers.org/talks/rsvp_dRPk7eb_QDo)

I will be presenting my Control+S concept, which is a tool that allows us to do governance, risk, and compliance work, but it deploys AI agents in sandboxes to perform the bulk of the work. This means that we can assess an organization against various frameworks (such as ISO 27001, the CIS 18 Citical Controls, NIST CSF) by doing it with a evidence first approach, which then gets pushed into a sandbox to be analyzed, and the results are then surfaced on the web UI. And I'll be showing the tech stack, the process of building it, and then the app itself.

- Event context: AI Tinkerers Toronto - December Meetup sponsored by Auth0 and TribalScale! — 2025-12-03 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_dRPk7eb_QDo

### [Building Voice-First AI Agents: Real-Time Orchestration with WebSockets and LiveKit](https://sf.aitinkerers.org/talks/rsvp_QACgZtoPuiQ)

I'll demo a voice-controlled AI coding agent that delegates work to parallel sub-agents while maintaining bidirectional sync across terminal, web, and mobile. The core challenge: how do you coordinate multiple autonomous agents in real-time while enabling voice interaction? I'll walk through the technical architecture: - Agent orchestration: How the main agent spawns workers for parallel execution and aggregates results - Real-time sync: WebSocket relay architecture that broadcasts messages via Redis PubSub to all connected clients - Voice integration: Connecting LiveKit's WebRTC audio to the agent via separate channels (audio through LiveKit, commands through WebSocket relay) - Async voice notifications: Using debounced triggers to make the voice agent proactively speak when background tasks complete The interesting bits: handling the dual-connection model (audio vs. text), preventing message echo loops in pubsub, and designing the database schema to support hierarchical agent sessions with parent/child relationships. Code walkthrough will cover TypeScript agent orchestration, Python voice agent with STT/TTS, and the WebSocket relay protocol.

- Event context: AI Tinkerers x Google Cloud SF Meetup — 2025-11-21 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_QACgZtoPuiQ

### [Ambient Code - Creating an enterprise agentic coding platform that builds itself](https://boston.aitinkerers.org/talks/rsvp_ZHEqQK0TQbw)

A fast, open-source agent-execution platform that unifies frontend (Next.js, React, Tailwind) and backend runners (Python, Claude Agent SDK, Anthropic, websockets, async I/O) into a cohesive system for building local-first, containerized AI agents. The talk walks through architecture, runners, real-time execution flows, and how Ambient-Code enables reproducible agent workspaces for developers.

- Event context: AI Tinkerers Boston Meetup November 2025 — 2025-11-17 — Boston
- Public talk page: https://boston.aitinkerers.org/talks/rsvp_ZHEqQK0TQbw

## Related Technologies

- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 215 public demos
- [Codex](https://aitinkerers.org/technologies/codex) ([Markdown](https://aitinkerers.org/technologies/codex.md)) — 44 public demos
- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [Agent](https://aitinkerers.org/technologies/agent) ([Markdown](https://aitinkerers.org/technologies/agent.md)) — 12 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 173 public demos
- [Codex SDK](https://aitinkerers.org/technologies/codex-sdk) ([Markdown](https://aitinkerers.org/technologies/codex-sdk.md)) — 2 public demos
- [FastAPI](https://aitinkerers.org/technologies/fastapi) ([Markdown](https://aitinkerers.org/technologies/fastapi.md)) — 181 public demos
- [GitHub](https://aitinkerers.org/technologies/github) ([Markdown](https://aitinkerers.org/technologies/github.md)) — 74 public demos
- [MCP](https://aitinkerers.org/technologies/mcp) ([Markdown](https://aitinkerers.org/technologies/mcp.md)) — 129 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 186 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 205 public demos
- [AGENTS](https://aitinkerers.org/technologies/agents) ([Markdown](https://aitinkerers.org/technologies/agents.md)) — 20 public demos
- [Anthropic](https://aitinkerers.org/technologies/anthropic) ([Markdown](https://aitinkerers.org/technologies/anthropic.md)) — 36 public demos
- [@anthropic-ai/claude-agent-sdk](https://aitinkerers.org/technologies/anthropic-ai-claude-agent-sdk) ([Markdown](https://aitinkerers.org/technologies/anthropic-ai-claude-agent-sdk.md)) — 1 public demo
- [Anthropics SDK](https://aitinkerers.org/technologies/anthropics-sdk) ([Markdown](https://aitinkerers.org/technologies/anthropics-sdk.md)) — 1 public demo
- [Apertus-8B](https://aitinkerers.org/technologies/apertus-8b) ([Markdown](https://aitinkerers.org/technologies/apertus-8b.md)) — 1 public demo
- [AWS](https://aitinkerers.org/technologies/aws) ([Markdown](https://aitinkerers.org/technologies/aws.md)) — 38 public demos
- [AWS CDK](https://aitinkerers.org/technologies/aws-cdk) ([Markdown](https://aitinkerers.org/technologies/aws-cdk.md)) — 3 public demos