Workshops

Ultimate Private AI

Bill Kennedy — Managing Partner, Ardan Labs

Bill Kennedy

Workshop Description

This is a hands-on, full-day workshop where you'll go from zero to running open-source models directly inside your Go applications — no cloud APIs, no external servers, no data leaving your machine.

You'll start by loading a model and running your first inference with the Kronk SDK. Then you'll learn how to configure models for your hardware — GPU layers, KV cache placement, batch sizes, and context windows — so you get the best performance out of whatever machine you're running on. With the model tuned, you'll take control of its output through sampling parameters: temperature, top-k, top-p, repetition penalties, and grammar constraints that guarantee structured JSON responses.

Next you'll see how Kronk's caching systems — System Prompt Cache (SPC) and Incremental Message Cache (IMC) — eliminate redundant computation and make multi-turn conversations fast. You'll watch a conversation go from full prefill on every request to only processing the newest message.

With the foundation solid, you'll build real applications: a Retrieval-Augmented Generation (RAG) pipeline that grounds model responses in your own documents using embeddings and vector search, and a natural-language-to-SQL system where the model generates database queries from plain English — with grammar constraints ensuring the output is always valid, executable SQL.

Each part builds on the last.

By the end of the day, you won't just understand how private AI works — you'll have built applications that load models, cache intelligently, retrieve context, and generate code, all running locally on your own hardware.

What You Will Learn

By the end of this workshop, you'll leave with working code, a deep understanding of local model inference in Go, and hands-on experience across the full stack: model configuration, performance tuning, intelligent caching, retrieval-augmented generation, and structured code generation.

Hardware Requirements

Don't worry if you don't have the full hardware required — the instructor will provide everything you need to follow along and run the examples.

  • Mac M1 series with at least 16 GB RAM (preferred 32 GB+)
  • Any Linux/Windows laptop with a dedicated GPU with at least 8 GB VRAM (not system RAM) (preferred 16 GB)
  • Access to a cloud-based instance with a dedicated GPU with at least 8 GB VRAM (preferred 16 GB)

Prerequisites

  • Several months of Go coding experience
  • A working Go environment on the device you'll bring to class

Recommended Preparation

  • Clone the main repo: github.com/ardanlabs/kronk
  • Read the notes in the makefile for installing all tooling and testing the code before class
  • Email the instructor, Bill Kennedy, for assistance

Bio

William Kennedy is a managing partner at Ardan Labs in Miami, Florida. Ardan is a group of passionate engineers, artists and business professionals focused on building and delivering reliable, secure and scalable solutions. Bill is also the author of Go in Action and the Ultimate Go Notebook, plus the author of over 100 blog posts and articles about Go. Lastly, he is a founding member of GoBridge and the GDN, organisations working to increase Go adoption through diversity.

Twitter

BUY TICKET

Go Faster with Agents: Build Your Own Claw in Go

Daniel Mahlow — Managing Partner & Generative AI Lead, Contiamo

Daniel Mahlow

Workshop Description

Claws — always-on, autonomous AI agents like OpenClaw and NanoClaw — are changing how people interact with AI. Unlike coding agents that wait for your commands, a claw runs continuously, remembers context across sessions, schedules its own tasks, and acts on your behalf. This hands-on workshop walks you through building your own claw from scratch in Go, covering everything from the core reasoning loop to inter-agent communication.

Starting from an empty main.go, we'll build a fully functional claw step by step: the agent reasoning loop, tool registration and execution, streaming responses, persistent memory, autonomous scheduling, and a web UI to interact with your agent. We'll use coding agents throughout the process — building an AI agent with the help of AI agents — while reviewing and understanding every layer of what gets produced.

Go's concurrency model maps directly to claw architecture. Goroutines handle parallel tool execution and background scheduling naturally. Channels deliver streaming LLM responses. The type system keeps tool schemas honest. And a single binary deployment means your claw runs anywhere — on your laptop, a Raspberry Pi, or a VPS — without runtime dependencies.

The workshop progresses through carefully designed demonstrations, each building on the previous. Along the way you'll learn to manage context windows, apply conversation compaction strategies, and evaluate security boundaries for agent systems. The final demonstration connects all participant-built claws via Google's A2A (Agent-to-Agent) protocol, where your agents discover peers on the network and begin collaborating autonomously — delegating tasks, sharing results, and solving problems together across the room.

While you're building a personal agent, the patterns transfer directly to production use cases: internal knowledge assistants, automated ops tools, LLM-powered APIs, and service-to-service coordination. The agent loop, tool system, and concurrency patterns you implement are the same foundations your team will need for any Go-based LLM integration.

What You Will Learn

Agent Fundamentals
  • Master the agent reasoning loop from first principles: prompt assembly, LLM inference, tool dispatch, and result integration
  • Implement a flexible tool registration system using Go interfaces and JSON schema generation
  • Handle streaming LLM responses using goroutines and channels
  • Understand context window management and conversation compaction strategies
Building a Claw
  • Build persistent memory so your claw remembers across sessions and restarts
  • Create autonomous scheduling — your claw acts without being asked
  • Develop a web UI for real-time interaction with your agent
  • Apply Go concurrency patterns (errgroup, fan-out/fan-in) to parallel tool execution
  • Evaluate architecture decisions for agent systems: sandboxing, permissions, and security boundaries
Multi-Agent Networking
  • Implement the A2A (Agent-to-Agent) protocol for agent discovery and communication using the official Go SDK
  • Connect your claw to peers for collaborative, multi-agent workflows across the network

Prerequisites

  • Basic knowledge of Go programming
  • Familiarity with command-line interfaces
  • A conceptual understanding of APIs and server-client interactions (agent and protocol concepts will be introduced)
  • Access to Claude, GPT-4o, Gemini, or similar LLM API (instructions provided before the workshop)
  • A working Go development environment (Go 1.22+ recommended)
  • Experience with generative AI coding tools or agents is beneficial but not mandatory

Recommended Agentic Coding Environments (Optional)

Preparation

  • Clone the workshop repository (link provided before the session)
  • Ensure your Go environment and chosen AI assistant (API access or tool) are set up and working
  • Optional: Install Ollama for local model fallback

Bio

Daniel Mahlow is managing partner and generative AI lead at Contiamo, a Berlin-based consultancy. He has worked on various software and data engineering projects and since 2020 has been driving generative AI projects from prototype to large-scale production. He is a generalist, a builder, and enjoys diving into new technology.

BUY TICKET