# Anthropic API Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/anthropic-api
> Markdown URL: https://aitinkerers.org/technologies/anthropic-api.md
> Technology record last updated: 2026-02-22T17:01:16Z
> Generated: 2026-08-26T16:23:58Z

Programmatic access to Anthropic's Claude models (Opus, Sonnet, Haiku) for complex reasoning, vision, and tool-use applications.

The Anthropic API delivers programmatic access to the Claude model family (Opus, Sonnet, Haiku), enabling developers to integrate state-of-the-art AI into applications. Use the Messages API for conversational tasks, leveraging Claude 3.5 Sonnet for balanced performance or Claude 3 Opus for complex analysis. Key features include Tool Use (function calling), Vision capabilities for image analysis, and a large 200K token context window for extensive document processing. This API provides a powerful, reliable foundation for next-generation AI projects.

- Official technology site: https://docs.anthropic.com
- Public AI Tinkerers demos and talks: 63
- Result page: 1 of 3

## Recent Public Talks and Demos

### [Selling AI Agents With AI Agents](https://boston.aitinkerers.org/talks/rsvp_CoVeIXBfmhM)

I sell an AI quoting agent to screen printing shops, and I am a solo founder building around a day job, so the constraint is hours, not ideas. I built an outbound GTM engine that runs on a Mac Mini on my desk and works the pipeline while I am at work: weekly lead sourcing and qualification against a narrow ICP (owner-operated shops with an automatic press and an existing quote form), personalized first-touch outreach, revival sequences for dead leads, cadenced follow-up for warm leads, and a Slack command center that flags replies, requests approvals, and tees up the one thing I refuse to automate: the phone call. The product being sold follows the same pattern. The quoter reads messy inbound requests with an LLM, the shop's own deterministic pricing rules calculate every number, and it flips inbound to outbound by chasing stale quotes automatically.

- Event context: Back from Summer: AI GTM Builders — 2026-09-03 — Boston
- Public talk page: https://boston.aitinkerers.org/talks/rsvp_CoVeIXBfmhM

### [Self-Hosting Open Weight Models: What It Actually Cost Us in Production](https://san-diego.aitinkerers.org/talks/rsvp_mMKaJmBkaYE)

We ran a self-hosted open weight vision model in production for a document pipeline processing about 105,000 pages a month, then finally measured it properly against the managed alternatives. This is the result: three approaches scored field by field against human-corrected ground truth on 100 real documents, 1,759 field comparisons, with real cost per accurate field. Two findings reframed our roadmap. First, our 83 percent accuracy looked like proof the open weight model was the right call, until we excluded six fields that were database joins rather than extraction, at which point our lead over a turnkey managed service collapsed to 2 points. We had spent months crediting the model for what was really a boring integration. Second, self-hosted inference came in at 0.7x the per-token frontier cost, not the 10x saving everyone assumes, and the model layer was only about two thirds of the bill, so the swap moves less than the per-page math suggests. You will also get the trick that made all of it measurable without a labeling budget: if your pipeline has a human review step and your output bucket has versioning on, version zero versus latest version is an already-labeled error set, field by field, going back as far as your retention. We found 276,000 corrected pairs nobody had ever read as a dataset. The harness behind the numbers is open source, so you can run the same comparison on your own data. Client details and dollar amounts are anonymized, everything else is real.

- Event context: Self-hosting Models and Managing Token Spend — 2026-08-21 — San Diego
- Public talk page: https://san-diego.aitinkerers.org/talks/rsvp_mMKaJmBkaYE

### [The Interview That Runs Itself](https://seattle.aitinkerers.org/talks/rsvp_HVXP2AFZt-U)

I built a brand-discovery workshop that runs itself: an ElevenLabs voice agent interviews you about your brand, and while you're still talking, Claude mines the live transcript and pops "nuggets" (quotable insights) onto the screen in real time — then turns each section of the conversation into structured deliverables: a brand voice guide, an ICP profile, and a channel strategy. I used to run this workshop by hand — 90 minutes per client plus waiting on transcripts — so I automated the interviewer out of the room, starting with me. Live, I'll talk to the agent on stage so you can watch insights get captured mid-sentence, walk the two-model architecture on an interactive deck that replays a real session using the app's actual pacing and threshold code, and show the working system deployed at workshop.trymarketingmachine.com.

- Event context: AI Tinkerers Seattle Summer Bash — 2026-07-29 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_HVXP2AFZt-U

### [The Completion Utility Stack: Launching Thousands of AI-Native Businesses for the Agentic Economy](https://orange-county.aitinkerers.org/talks/rsvp_g0ZRnVDKJI8)

I built NetShow IQ1, the full agentic operating stack from NetShow.AI for creating AI-first, AI-native businesses where digital crews move users from intent to completed outcome. IQ1 is designed around the Completion Utility: the idea that, just as electricity, water, and gas became foundational utilities for modern life, reliable task completion becomes a new utility for the agentic economy. In the live demonstration, I’ll show how IQ1 turns a request like “I need this handled” into an orchestrated workflow across virtual agents, tools, memory, MCPs, skills, approvals, and reporting. I’ll walk through the working system, architecture, agent harness, workflow routing, tool calls, logs, and how a business-specific digital crew can be composed for real consumer and business services. NetShow.AI is building economic infrastructure for thousands of AI-first businesses and services across major categories of life, work, commerce, local services, operations, support, home, and environment.

- Event context: AI Tinkerers Orange County: Tuesday, July 21, 2026 at Centercode — 2026-07-22 — Orange County
- Public talk page: https://orange-county.aitinkerers.org/talks/rsvp_g0ZRnVDKJI8

### [Evaluating Multi-Agent Systems Beyond the Final Answer](https://seattle.aitinkerers.org/talks/rsvp_lgxuusz0aeg)

I am building an evaluation framework for multi-agent AI systems that compares not only whether the system gets the right final answer, but how the agents collaborate to get there. In the live demo, I will show a small multi-agent workflow with a planner agent, worker agents, and a critic/evaluator agent, then walk through the code, traces, tool calls, handoffs, failure cases, and scoring logic used to evaluate each run. The framework captures the full agent trajectory: which agent took control, what tools were called, where context was passed or lost, how much the run cost, how long it took, and whether the final outcome matched the task goal. I will demo how the same task behaves under different setups, such as a single-agent baseline, a manager-agent architecture, and a multi-agent handoff design.

- Event context: Women in AI - Builders Track: Seattle Inaugural Meetup — 2026-07-15 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_lgxuusz0aeg

### [Does your coding harness actually do anything? Measuring it, fairly.](https://boston.aitinkerers.org/talks/rsvp_bx0CiDi1_uo)

Everyone's bolting "harnesses" onto coding agents — Superpowers, GSD, Agent-Skills, Compound Engineering — but does the scaffolding actually make the model build better software, or just feel better? CodingHarness.xyz is an open eval that pits these frameworks head-to-head: same spec, same model, isolated sandboxes, and an evidence-based rubric (does it meet the PRD? is the code any good?). I'll share the surprising result — an inverse-scaling effect lifted straight from a recent Xiaomi paper and reproduced on real runs: harnesses help most exactly where the base model is weakest, and barely at all where it's already strong. Even better, it's framework-dependent — one framework tracks the curve almost perfectly, another inverts it and only helps strong models. Live demo of the eval studio: watch two frameworks build the same app, stream the agent's work turn-by-turn, and see the marginal-gain scorecard light up green/red. Plus a sneak peek at turning framework competitions into a spectator sport (think FIFA bracket, but for coding agents).

- Event context: AI Tinkerers Boston: GTM Agentic AI Launch — 2026-06-29 — Boston
- Public talk page: https://boston.aitinkerers.org/talks/rsvp_bx0CiDi1_uo

### [MARSYS: Multi-Agent Workflows Without the Plumbing](https://lausanne.aitinkerers.org/talks/rsvp_eigQG2pH8qI)

MARSYS is an open-source Python framework for building multi-agent workflows. Define your agents and who talks to who -- the framework handles parallel execution, branch isolation, convergence, context management, and routing automatically. It works with 7+ LLM providers out of the box (OpenAI, Anthropic, Google, local models), ships with ready-to-use agents (browser, file operations, code executor, data analyst), and lets you fine-tune local models directly from execution traces. `pip install marsys` and you're running.

- Event context: AI Tinkerers Lausanne April 2026 Meetup — 2026-04-30 — Lausanne
- Public talk page: https://lausanne.aitinkerers.org/talks/rsvp_eigQG2pH8qI

### [Lixpi is a visual, node-based workflow engine for building AI image and video generation pipelines](https://toronto.aitinkerers.org/talks/rsvp_SxMp4PNqTxU)

Lixpi is a visual, node-based workflow engine for AI image and video pipelines an infinite canvas where spatial arrangement is the workflow. Instead of writing a workflow DSL or fighting a linear chat prompt, you drop documents, images, and AI chat threads onto the canvas and draw edges between them. The edge graph directly drives context extraction, dependency chains, and execution order for the underlying models. In the demo I'll show live character-consistent image generation via "artifact piping" (one generated image fanned out as edge-context into multiple downstream threads), mid-conversation model switching between OpenAI / Anthropic / Google, and progressive image streaming rendered into the node in real time.

- Event context: AI Tinkerers Toronto - April 2026 - hosted by Shopify — 2026-04-29 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_SxMp4PNqTxU

### [Your GTM Copy Only Reaches 32% of Buyers — Here's How to Measure It](https://seattle.aitinkerers.org/talks/rsvp_UuJIGqJNdf0)

COS is a content measurement engine that scores how well B2B sales and marketing copy resonates across all five buyer personality types (Big Five/OCEAN). It orchestrates 7 parallel analysis frameworks through a 24-module knowledge base (~38K lines of psychology research) to surface which buyer segments you're reaching and which you're missing. Live at cos.semalytics.com, free guest mode, no signup.

- Event context: AI Tinkerers Seattle: GTM Engineering — April Meetup — 2026-04-23 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_UuJIGqJNdf0

### [Anthropic Ambassador Chile](https://santiago.aitinkerers.org/talks/rsvp_HCvohBDd5hs)

Claude Community Ambassador at Anthropic Chile — one of 9 leaders selected globally for the Claude Impact Lab program. Builder and founder of Bendita IA (4,500+ members), Chile's most active AI community, and Zyvor, Latin America's first autonomous growth agency operated by AI agents. Architect of Agent OS — an operating system for orchestrating intelligent agents in organizations, defining how companies deploy and govern AI at scale. Focused on one thing: moving Latin America from AI consumer to AI builder.

- Event context: 🔥 AI TINKERERS - SANTIAGO / CAPÍTULO #10 / 2026 — 2026-04-16 — Santiago
- Public talk page: https://santiago.aitinkerers.org/talks/rsvp_HCvohBDd5hs

### [Wisdom Layer: Agent Cognitive Architecture](https://manchester-nh.aitinkerers.org/talks/rsvp_hAZ9fGsxhsI)

The Wisdom Layer is a Python SDK that wraps any LLM with persistent memory that matures, autonomous reflection cycles, self-authored behavioral rules with a lifecycle, and an internal critic that evaluates output against active rules before it ships. The demo at AI Tinkerers ran on Claude Haiku — Anthropic's cheapest model — and showed how a commodity model becomes substantially more reliable when scaffolded with memory, reflection, and enforcement, rather than fine-tuned. Early benchmark showed fabrication rate dropping from 22% to 2% on the same model (n=45 single corpus, broader eval in progress). The same architecture also powers loom-code (AI-assisted coding across 20+ repos) and a computational pharmacogenomics research platform in active collaboration discussions with academic cancer centers.

- Event context: AI Tinkerers Manchester (Bedford), NH - April 2026 Meetup — 2026-04-15 — Manchester NH
- Public talk page: https://manchester-nh.aitinkerers.org/talks/rsvp_hAZ9fGsxhsI

### [From ServiceNow Ticket to Terraform Pull Request using Skills, MCP with Coding Agents](https://nashville.aitinkerers.org/talks/rsvp_3hn_1rgR6k0)

Most coding agents are really good at generating infrastructure code from scratch. But how to steer them to follow existing Terraform conventions in the form of base modules: encoding security policies, tagging standards for cost allocation, naming conventions, and compliance guardrails into reusable building blocks. These modules are how we enforce consistency across environments, track cloud spend back to business units, and pass regulatory audits. In this talk, I'll show you how to use skills to define a better infrastructure provisioning workflow. One that steers coding agents to first discover your existing conventions, understand the risks, implement changes within those guardrails, and provide full visibility into every decision made along the way. This gives cloud operations teams the ability to orchestrate infrastructure requests with human-in-the-loop validation at every stage, see huge productivity gains The system uses coding agents designed to work directly on a filesystem—reading and modifying code, running bash commands and interacting with real repositories. Built using Agent Skills and the Claude Agents SDK, this talk walks through how the workflow is structured, what works today. I'll also cover how this approach is agnostic to agent runtimes and model providers - built on open standards (MCP + Skills), so you're not locked into any single vendor and how the same pattern extends to other tasks across the enterprise beyond infrastructure provisioning.

- Event context: AI Tinkerers Nashville – Software Development in the Age of AI — 2026-03-25 — Nashville
- Public talk page: https://nashville.aitinkerers.org/talks/rsvp_3hn_1rgR6k0

### [KickBench - Can LLMs predict Bundesliga games?](https://bremen.aitinkerers.org/talks/rsvp_X3CJBTY3YUk)

I let LLMs with a very generic prompt and a websearch tool predict bundesliga matches and then rate the predictions based on real game results. For every prediction of every LLM I save the full trace, so that I can compare what different models search for or how different models reason about bundesliga games.

- Event context: AI Tinkerers Bremen — 2026-03-25 — Bremen
- Public talk page: https://bremen.aitinkerers.org/talks/rsvp_X3CJBTY3YUk

### [Prompt Stretching: Applying Linear Transformations and Recursive Decomposition to Prompts](https://la.aitinkerers.org/talks/rsvp_nkNEynHMFvs)

I'll walk through an open source Python library I'm working on where LLMs generate other LLMs as reusable JSON configs. The core demo is "prompt stretching" — a pipeline that takes a single user prompt and fans it out through a family tree of transformations (inverse, abstract up/down, reflection, rotation, shear, scaling, recursion, dimension shift). Then I'll also demo subprompting — recursively decomposing a prompt into a tree of subprompts at configurable depth and branching factor (e.g. n=[4,3,2]), with concurrent execution, so anyone can build their own deep research agent. Finally, all the transformed/decomposed prompt variants and their responses can be pairwise evaluated.

- Event context: AI Tinkerers LA: March Builder Meetup & Live Demos — 2026-03-20 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp_nkNEynHMFvs

### [rm -rf salesforce — Claude Runs Deal Flow Now](https://seattle.aitinkerers.org/talks/rsvp_qa7m-04lrlg)

I built a git-backed knowledge base that replaces both my CRM and Google Docs for running an early-stage fund. Every entity — founders, companies, deals — lives as a folder of markdown and YAML. Claude agents are first-class participants: they process inbound emails, run entity resolution, create records, log notes, and commit directly to the repo. A GitHub Actions cron runs nightly, calling Claude Sonnet to synthesize each entity's raw files into a structured materialized summary. I'll demo the full live workflow: forward a pitch email → agent resolves the entity → creates the records → generates a materialized view → commits to git. No database. No SaaS. Just files, Claude, and git.

- Event context: AI Tinkerers Seattle: GTM Engineering Kickoff — Building AI for Growth — 2026-02-26 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_qa7m-04lrlg

### [Kokoro on the web](https://la.aitinkerers.org/talks/rsvp_iMNQYyRB6MM)

Expanded my iOS app for summarizing any article into 3 levels of detail, into a web app so Android users can use it. To save money I’ve got a free (for low usage) PaaS running Kokoro (the same TTS I’m running directly on the iPhone). Shocking how much cheaper it is, even at usage beyond free level. Also found my existing prompts (Llama 3.2 and Apple Intelligence on iOS, as well as Claude Sonnet via API) have consistent accuracy issues, which I’m still working on.

- Event context: AI Tinkerers LA: February Builder Meetup & Live Demos — 2026-02-24 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp_iMNQYyRB6MM

### [Goals are (mostly) all you need](https://nyc.aitinkerers.org/talks/rsvp_PBqaVIPH89A)

I have created a goal editing system: an LLM changes goals on the fly. I will demonstrate it on a floorpan design system.

- Event context: Feb Demo Day: How are you turning design into code? (with Baz) — 2026-02-04 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_PBqaVIPH89A

### [Brief: build context infrastructure so agents stop guessing](https://seattle.aitinkerers.org/talks/rsvp_pul20-6rImI)

A CLI that gives coding agents a deterministic understanding of how your code works. Brief helps Claude Code complete tasks 30% faster and use up to 45% fewer tokens. When an AI agent needs to modify something in your codebase, it searches around - grepping, reading files, building a mental model one piece at a time. Brief replaces that with a single query. You ask `brief context "how does task creation work"` and it locates key information, dynamically traces execution paths, and returns a layered understanding of where everything is and how it works. The agent starts with a complete picture of what exists and how it works, rather than spending time and tokens figuring out what is usually an incomplete or flawed understanding before doing the actual work. Brief provides telescoping context across the codebase, zoomed to the correct level for each relevant part: AST parsed manifest of every class, function, and dependency, traced execution flows through the call chain, LLM summaries of what each method and file does, detected conventions/contracts, and related code. I'll demo the core loop, show how the static analysis and dynamic tracing work under the hood, and walk through what a real context package looks like at each layer - from high-level file descriptions down to traced execution paths with code. This is a working tool I use daily with Claude Code. I'll show where it works well, where it breaks, and how I think it could be improved or built upon.

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

### [Observability that drives true ROI](https://toronto.aitinkerers.org/talks/rsvp_6R-ayo9yb7I)

As AI agents increasingly act like employees, we rethought what observability should look like in this new era. Instead of more dashboards and logs, we built a crew of AI managers that monitor, understand, and summarize agent behavior. The goal is simple: help teams quickly see what matters, understand why it’s happening, and take action without engineers spending hours digging through traces and logs.

- Event context: AI Tinkerers Toronto - January 2026 Meetup at Google! — 2026-01-29 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_6R-ayo9yb7I

### [Progressive Disclosure for an NL to Automation Pipeline](https://austin.aitinkerers.org/talks/rsvp_ekHvhOVKLWA)

I'll be presenting on how I built a working natural to standing automation pipeline for my app Juniper - it allows users to give requests like "do this when I get X message in Slack" or "every Sunday at 8pm, give me a weekly wellness report." I will talk about how the agent discovers available actions via db fetches and writes JSON declarative executables as well as how those scripts are validated and executed.

- Event context: AI Tinkerers Austin: January 2026 Demo Night — 2026-01-23 — Austin
- Public talk page: https://austin.aitinkerers.org/talks/rsvp_ekHvhOVKLWA

### [My Dog Thinks We’re Walking, But I Think We're Coding: The IRL Async Agent Loop](https://montreal.aitinkerers.org/talks/rsvp_PcSIDtJhJo4)

Gatewayz started as a way to solve a personal problem: I needed a clean, fast, and observable way to route traffic across multiple LLM providers without rewriting my stack every time a new model dropped. This talk walks through how Gatewayz was built from the ground up, completely with Claude Code over the course of a 2 week sprint. I’ll demo the architecture, how requests are normalized and routed, how latency and cost are tracked in real time, and how I avoided turning the system into an un-debuggable distributed nightmare.

- Event context: AI Tinkerers Montreal - January 2026 Meetup at Ateko — 2026-01-21 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_PcSIDtJhJo4

### [AgentFlow: Building an AI Agent Distribution Platform from Scratch](https://orange-county.aitinkerers.org/talks/rsvp_QG1-GhPpKw8)

I built AgentFlow - a platform that lets you connect your AI agents, workflows, or LLM endpoints, then distribute them across teams and organizations with built-in access control and conversation tracking. The problem: You've built cool AI agents, but how do you actually get them into users' hands? You need auth, multi-tenancy, usage tracking, conversation history, and a way to swap between different AI backends without rebuilding your frontend. I'll walk through the platform architecture: - Multi-tenant organization system with group-based access control (users → groups → AI models) - Conversation management with feedback collection - How any team member can chat with approved AI connections through one interface Technical deep dive on the Universal Endpoint Router - the core system that lets you plug in ANY AI backend: - Connect OpenAI, Anthropic, custom webhooks, or your own AI SDK agents - Automatic stream format conversion (SSE → UI Stream, JSON → Streamed Text) - Template-based request/response mapping with JSONPath extraction - Non-blocking persistence that intercepts streams in real-time without affecting latency Tech stack: Next.js 14, TypeScript, AI SDK 6, Supabase + Row-Level Security, Clerk

- Event context: AI Tinkerers OC - January 14, 2026 Meetup: Welcome to 2026! — 2026-01-15 — Orange County
- Public talk page: https://orange-county.aitinkerers.org/talks/rsvp_QG1-GhPpKw8

### [Using Claude Code to X-Ray Claude Code to build a Claude Code Tracking App](https://seattle.aitinkerers.org/talks/rsvp_sg603_B4uBk)

The demo discusses the process of building Shinzo, an app that allows you to record your Claude Code sessions and share them with others. This will cover the application itself (architecture and usage) as well as the technical steps required to x-ray Claude Code (applying code-mode to explore the complex interaction patterns, source code analysis, and system prompts).

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

### [Shotgun: Spec-Driven Development](https://poland.aitinkerers.org/talks/rsvp_T7O21j3kLXo)

A live, TUI‑only, code‑first walkthrough of Shotgun—the open‑source assistant that turns your repo into a live, queryable code graph and then uses Agentic workflows to produce deep, codebase‑aware research and implementation‑grade specifications. In minutes it explodes those specs into precise, agent‑ready task lists you can hand directly to AI coding agents. We’ll index a repo, ask repo‑scoped questions, generate detailed specs with traceability to code, create executable tasks, and show just enough internals to prove how it works. This was largely built using Claude Code. After the shotgun was able to generate specs/research we used the Shotgun to generate specs to give to Claude Code to build the Shotgun itself. Also it's open-source and 100% in Python, contributors are welcome.

- Event context: AI Tinkerers Poland #6 - Meetup in Warsaw (26th November) — 2025-11-26 — Poland
- Public talk page: https://poland.aitinkerers.org/talks/rsvp_T7O21j3kLXo

## Related Technologies

- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 518 public demos
- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 654 public demos
- [FastAPI](https://aitinkerers.org/technologies/fastapi) ([Markdown](https://aitinkerers.org/technologies/fastapi.md)) — 178 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 185 public demos
- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 205 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 187 public demos
- [React](https://aitinkerers.org/technologies/react) ([Markdown](https://aitinkerers.org/technologies/react.md)) — 216 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 199 public demos
- [Node](https://aitinkerers.org/technologies/node) ([Markdown](https://aitinkerers.org/technologies/node.md)) — 96 public demos
- [LangChain](https://aitinkerers.org/technologies/langchain) ([Markdown](https://aitinkerers.org/technologies/langchain.md)) — 444 public demos
- [Supabase](https://aitinkerers.org/technologies/supabase) ([Markdown](https://aitinkerers.org/technologies/supabase.md)) — 88 public demos
- [AWS](https://aitinkerers.org/technologies/aws) ([Markdown](https://aitinkerers.org/technologies/aws.md)) — 37 public demos
- [Bun](https://aitinkerers.org/technologies/bun) ([Markdown](https://aitinkerers.org/technologies/bun.md)) — 18 public demos
- [Claude Sonnet](https://aitinkerers.org/technologies/claude-sonnet) ([Markdown](https://aitinkerers.org/technologies/claude-sonnet.md)) — 18 public demos
- [Google Cloud Platform](https://aitinkerers.org/technologies/google-cloud-platform) ([Markdown](https://aitinkerers.org/technologies/google-cloud-platform.md)) — 25 public demos
- [LangGraph](https://aitinkerers.org/technologies/langgraph) ([Markdown](https://aitinkerers.org/technologies/langgraph.md)) — 66 public demos
- [LLM](https://aitinkerers.org/technologies/llm) ([Markdown](https://aitinkerers.org/technologies/llm.md)) — 121 public demos
- [MCP](https://aitinkerers.org/technologies/mcp) ([Markdown](https://aitinkerers.org/technologies/mcp.md)) — 123 public demos

## More Results

- Next: https://aitinkerers.org/technologies/anthropic-api.md?page=2