# Agent Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/agent
> Markdown URL: https://aitinkerers.org/technologies/agent.md
> Technology record last updated: 2026-03-03T17:53:37Z
> Generated: 2026-09-21T06:47:09Z

An Agent is an autonomous software system (often LLM-driven) that perceives its environment, makes goal-directed decisions, and executes multi-step actions without continuous human oversight.

This is the next-generation automation layer: a software entity capable of independent operation. Agents utilize a core perception-action loop, integrating memory and planning systems to break down complex objectives (e.g., 'book a full business trip') into actionable subtasks. They are distinguished by their autonomy, moving beyond simple chatbots or rule-based scripts. Modern examples like AutoGPT and Devin AI demonstrate their capacity to use external tools (APIs, web browsers) and adapt their strategy in real-time, delivering a step-change in efficiency for enterprise workflows and complex data analysis.

- Official technology site: https://en.wikipedia.org/wiki/AI_agent
- Public AI Tinkerers demos and talks: 12
- Result page: 1 of 1

## Recent Public Talks and Demos

### [Turn your Homelab into a Dark Factory](https://cologne.aitinkerers.org/talks/rsvp_iWZxTrC9hQ8)

I turned my Homelab into a dark factory where I run an orchestrating agent that schedules and delegates work to other agents. There are two parts to this system: the control plane, which handles where agents run and how they run, and the data plane, which handles the actual work you commit (or not). We're going to see how I interact with a personal agent (Hermes, if I have time, I'll show my own agent) and how Hermes decides what to do next depending on our conversation. Instead of making Hermes write the code, it will delegate the tasks to different coding agents running in our own sandbox (built with Firecracker on top of a Proxmox VM). I'll walk you through the different components, how it works and why it matters (in particular the sandbox part).

- Event context: AI Tinkerers Cologne: World Cup Edition — 2026-07-15 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_iWZxTrC9hQ8

### [Operating an Agentic Homelab with Agent Guides](https://seattle.aitinkerers.org/talks/rsvp_wvjI8VfiuMM)

I built a multi-node homelab with layered, enterprise-grade security (passwordless auth, secrets management, host hardening) and an OpenTofu plus Ansible control plane for infrastructure and deployment. AI agents operate it instead of me clicking through consoles. In order to facilitate rapid iteration and configuration I created a new open-standard data format called Agent Guides, which are open, Skill-compatible markdown runbooks. Provisioning a new LXC, rotating credentials, or updating firewall settings are repetitive over time, but the details drift and some of the APIs have undocumented behavior, so a single prompt is unreliable and a fixed script breaks. Plain wiki runbooks aren't ideal because they go stale as soon as the environment changes. What I wanted was documented procedures an agent can follow but still improvise when it hits something unexpected. The guides for my homelab are executed primarily by agents, whose harness leaves an audit log to review afterwards, so another agent may update the guide automatically instead of rediscovering the same problem the next time.

- Event context: AI Dev Tools Track - Seattle - July 13 — 2026-07-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_wvjI8VfiuMM

### [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

### [Building Brushi: A Local VLM Agent That Understands Kids’ Drawings](https://toronto.aitinkerers.org/talks/rsvp_duZsN9qwZvs)

Brushi is a kids coloring and drawing app with a local multimodal AI companion that can observe what a child is creating and respond through a small, bounded interaction loop. The project explores a question I have been thinking about in my recent work on edge AI: small VLMs and LLMs should not be treated as weaker versions of large cloud models. Like children are not simply “small adults,” edge models behave differently because the system around them has to provide structure, grounding, and feedback. In the live demo, I’ll show the working Brushi app, the local VLM/agentic architecture, and the event loop that connects the child’s drawing activity to the AI mascot’s reactions. The demo will focus on the technical workflow: how drawing events are captured, how visual context can be passed to a local VLM, how the LLM layer interprets the learning or creative context, and how the app decides whether to encourage, guide, correct, or stay silent. I’ll show the architecture, app workflow, logs/traces from the interaction loop, and examples of where the system succeeds or fails when trying to understand a child’s drawing.

- Event context: AI Tinkerers Toronto - June 2026 - with Relay Financial x PostHog — 2026-06-30 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_duZsN9qwZvs

### [I Built An Agent To Be Me On LinkedIn (And It Failed Three Times)](https://boston.aitinkerers.org/talks/rsvp_vNaKz6EaPyc)

A multi-source, voice-conditioned content pipeline that produces scheduled LinkedIn and Twitter posts in my voice — used in production for inbound GTM as a solo consultant. Not "write a LinkedIn post about X." A weekly research-aggregation-and-generation loop with a human editorial gate. What runs end-to-end: Four input streams aggregated weekly: Daily tinkering / build-moment capture (via a custom skill that captures structured notes mid-flow) GitHub repo scan across active projects — surfaces interesting commits / changes / experiments Tunable web research on topics I care about (AI/agents, regulated industries, GTM patterns) Ambient activity log from the week Synthesis layer: all four streams are collapsed into a single weekly research document. This is the structured intermediate artifact everything downstream reads from — it's what turns "the agent posts random stuff" into "the agent posts from a coherent week of actual work." Voice-first writing system: custom voice guide + platform-specific generation guides. LinkedIn and Twitter are not "same model, different length" — they're different generation modes, with the voice guide as the shared spine. Critical reviewer: second agent reviews drafts for clarity, claim quality, and voice fidelity. Outputs edits, not rewrites. Typefully as the HITL editorial gate: scheduled posts land in Typefully. I review, edit, delete, or reschedule. Nothing posts without explicit approval. Important architectural decision — reusing an existing tool as the review UI instead of building one. What I'll show live: The weekly research doc (the structured input artifact — the room can read it) A live generation pass: research doc + voice guide → draft LinkedIn post The Typefully review pass — real editorial decisions, not theatre Side-by-side: a LinkedIn post that lands vs. a Twitter post the system breaks on (the format failure mode) The voice guide diffs I made to fix the "sounds like me but unintelligible" failure mode The public earlier-iteration version is open-source as the voice-first-writing plugin in my GitHub — internal current workflow has evolved past it but the public version is a usable starting point.

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

### [How We Built AI Agents That Buy Media Across 10+ Ad Platforms](https://seattle.aitinkerers.org/talks/rsvp_6LZbpmkAStQ)

Synter is an agentic AI platform that autonomously manages paid media campaigns across Google, Meta, LinkedIn, TikTok, Reddit, X, and Microsoft Ads. I'll demo the live system: how agents create campaigns, adjust bids, allocate budgets, and generate ad creatives in real time — no human clicking required. We'll look at the agent execution loop, the MCP server that lets Claude and Cursor control ad accounts directly, and the cross-channel dashboard that unifies data from all platforms.

- Event context: GTM / Growth Track - Seattle — 2026-05-27 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_6LZbpmkAStQ

### [Pull-architecture agents: how I forced myself to do growth work](https://valencia.aitinkerers.org/talks/rsvp_-p7b50BEZW0)

A multi-agent system that manufactures pull for the growth work — writing, conference follow-up, CRM hygiene, responding to news — that I'd otherwise skip when product and ops eat my week. Seven agents across five repos, two APIs, and two websites (one fully autonomous), all driven from the only two surfaces I actually live in: my terminal and Mattermost. The demo walks a live pass through the rig: a LinkedIn contact lands in our self-hosted CRM, an article draft gets pushed to a website, a post-conference follow-up gets queued — every action is a curl command an agent emits, with circuit breakers I can tighten in the moment or across the long arc.

- Event context: AI Tinkerers Valencia May Meetup — 2026-05-26 — Valencia
- Public talk page: https://valencia.aitinkerers.org/talks/rsvp_-p7b50BEZW0

### [ibaAgent: Agentic time-series analysis.](https://nurnberg.aitinkerers.org/talks/rsvp_DcXjk1ibxVU)

I developed an agentic system using LangGraph to analyze high-resolution time-series data via natural language. Since high-resolution data is too token-intensive for LLMs, the agent operates "blind" by dynamically writing and executing Python analysis scripts to process data locally. This is supported by a specialized memory architecture that allows the agent to iteratively build an internal map of undocumented, messy data stores, and a rigorous Langfuse experiment pipeline used to tune hyperparameters and prompts for predictable reasoning and precise tool use. Currently transitioning from proof-of-concept to product at iba AG, my demo will showcase LangGraph traces of the agent’s execution and its self-correction within the Python environment. I will also highlight our Langfuse evaluation workflow and how the memory layer enables the agent to navigate complex data structures over time. I’m looking to exchange ideas with fellow tinkerers specifically on memory persistence, planning strategies, and robust evaluation for agentic workflows.

- Event context: AI Tinkerers Nürnberg: April Meetup — 2026-04-22 — Nürnberg
- Public talk page: https://nurnberg.aitinkerers.org/talks/rsvp_DcXjk1ibxVU

### [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

### [From Benchmark to Agent: A2A‑Driven Werewolf Arena for Evaluating LLM Agents](https://bogota.aitinkerers.org/talks/rsvp_w6B43riADns)

Werewolf Arena is a multi‑agent social‑deduction benchmark built on the AgentX–AgentBeats stack, developed as part of the second cohort of TribuPapers and the 2025 Berkeley Agentic AI MOOC, and submitted to the AgentX–AgentBeats competition. It instantiates the Werewolf game as an 8‑player environment where a Green Agent orchestrator manages role assignment, day/night phases, interaction flow, and ELO‑style ratings, while multiple LLM‑driven Purple Agents connect via the A2A protocol to debate, vote, and execute actions under partial information. The project provides a research‑oriented evaluation pipeline that stress‑tests core agentic capabilities such as probabilistic reasoning, persuasion, deception and detection, role‑conditioned behavior, and narrative consistency in noisy multi‑agent settings. Each game produces both quantitative metrics (win‑rate by role, survival, vote accuracy, ELO adjusted by opponent strength) and qualitative scores via an LLM‑as‑a‑Judge component inspired by G‑Eval, which rates agents along multiple dimensions (reasoning quality, persuasive power, deceptive skill, adaptability, and consistency) and generates textual justifications. Technically, the system is implemented in Python with FastAPI for Green/Purple A2A endpoints, uses OpenAI LLMs (configurable models such as gpt‑4o‑mini) for both policies and judge, exposes a JavaScript/HTML/CSS leaderboard UI, and is fully containerized with Docker/Docker Compose and automated via GitHub Actions CI to run tournaments and update metrics reproducibly. The project was developed collaboratively by Daniel Santiago Sandoval Higuera, Sadid Alexis Romero Mahecha, Julian Anibal Henao Garcia, and Andres Felipe Garcia Sanchez.

- Event context: AI Tinkerers Bogotá: El Primer Meetup de 2026 — 2026-02-26 — Bogotá
- Public talk page: https://bogota.aitinkerers.org/talks/rsvp_w6B43riADns

### [Gmail/GCal Assistant](https://nyc.aitinkerers.org/talks/rsvp_JE6OrKu6Ins)

A demo of an agent built with Cohere and Langgraph that can help you search, summarize and prioritize a backlog of emails and upcoming calendar events.

- Event context: Agent Takeover with CrewAI — 2024-07-23 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_JE6OrKu6Ins

### [Building a coding agent in 5 minutes](https://sf.aitinkerers.org/talks/rsvp_zDq3eHR2urk)

Wordware allows you to rapidly build language model apps - everything from simple workflows to highly capable agents. Here I’ll demo the process of building an agent that can write and run code to solve complex tasks - just like Open AI’s code interpreter - in just 5 minutes

- Event context: 🤖🔄🧠 AI Tinkerers SF - October Meetup — 2023-10-26 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_zDq3eHR2urk

## Related Technologies

- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 215 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [Runtime](https://aitinkerers.org/technologies/runtime) ([Markdown](https://aitinkerers.org/technologies/runtime.md)) — 10 public demos
- [Claude Agent SDK](https://aitinkerers.org/technologies/claude-agent-sdk) ([Markdown](https://aitinkerers.org/technologies/claude-agent-sdk.md)) — 16 public demos
- [Claude (Anthropic)](https://aitinkerers.org/technologies/claude-anthropic) ([Markdown](https://aitinkerers.org/technologies/claude-anthropic.md)) — 2 public demos
- [FastAPI](https://aitinkerers.org/technologies/fastapi) ([Markdown](https://aitinkerers.org/technologies/fastapi.md)) — 181 public demos
- [LangGraph](https://aitinkerers.org/technologies/langgraph) ([Markdown](https://aitinkerers.org/technologies/langgraph.md)) — 67 public demos
- [MCP](https://aitinkerers.org/technologies/mcp) ([Markdown](https://aitinkerers.org/technologies/mcp.md)) — 129 public demos
- [Node](https://aitinkerers.org/technologies/node) ([Markdown](https://aitinkerers.org/technologies/node.md)) — 99 public demos
- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [A2A](https://aitinkerers.org/technologies/a2a) ([Markdown](https://aitinkerers.org/technologies/a2a.md)) — 7 public demos
- [Agentic loop architecture](https://aitinkerers.org/technologies/agentic-loop-architecture) ([Markdown](https://aitinkerers.org/technologies/agentic-loop-architecture.md)) — 1 public demo
- [Anthropic](https://aitinkerers.org/technologies/anthropic) ([Markdown](https://aitinkerers.org/technologies/anthropic.md)) — 36 public demos
- [Apertus-8B](https://aitinkerers.org/technologies/apertus-8b) ([Markdown](https://aitinkerers.org/technologies/apertus-8b.md)) — 1 public demo
- [APIs](https://aitinkerers.org/technologies/apis) ([Markdown](https://aitinkerers.org/technologies/apis.md)) — 19 public demos
- [Astro](https://aitinkerers.org/technologies/astro) ([Markdown](https://aitinkerers.org/technologies/astro.md)) — 3 public demos
- [base models](https://aitinkerers.org/technologies/base-models) ([Markdown](https://aitinkerers.org/technologies/base-models.md)) — 2 public demos
- [child-friendly controls](https://aitinkerers.org/technologies/child-friendly-controls) ([Markdown](https://aitinkerers.org/technologies/child-friendly-controls.md)) — 1 public demo