An agent is a loop, a handful of tools, and a lot of ordinary engineering discipline. Go happens to be very good at all three. No Python in the stack, and no time spent arguing about it.

This is a code-first walk through a complete agentic application written in Go. It ingests a user's documents, OCRs whatever isn't already text, indexes them, and answers questions over that material. It compiles in under 60 seconds, ships as a ~20MB static binary, runs in around 20MB of memory, and scales horizontally without anyone having to think hard about it.

We build it from the inside out, in idiomatic Go:

- The agent loop: plain control flow over a typed message history, with context.Context threaded through so cancellation and timeouts actually work
- Tools as interfaces: one small interface, JSON schemas derived from your types, a dispatch table, and compile-time safety over everything the model is allowed to call
- Streaming: token and event streams as channels, fanned out to callers without leaking goroutines
- Concurrency where it earns its keep: parallel ingestion and OCR with errgroup, bounded worker pools, and backpressure against a rate-limited API
- State and retrieval: conversation history and document index behind interfaces, as data you can inspect, diff and replay
- Testing: recorded model responses, table-driven tests over agent behaviour, and how to assert on something non-deterministic
- Failure modes: retries, partial tool failures, malformed model output, and the ones that only show up under load

Along the way, the things that actually bit us in production: schema drift between tool definitions and their handlers, prompt assembly degenerating into string soup, and why the boring observability work matters more than which model you picked.

Not a slide deck about AI. A working system, with the code on screen.

Takeaways

- A concrete architecture for agentic applications in Go, end to end
- How Go primitives (interfaces, channels, context, errgroup) map onto agent orchestration
- Patterns for tool definition and dispatch that stay type-safe as the tool set grows
- How to test and observe something that is non-deterministic by design
- The operational payoff: small binaries, small memory, fast builds, cheap horizontal scale

Preferred duration: 45 minutes including Q&A. Can be delivered in 30 or 60 minutes on request.

Target audience: Go developers, intermediate to advanced. Fluency in Go is assumed; no AI or machine learning background required.

Technical requirements: my own laptop (USB-C / HDMI) and internet access for the live demo. A recorded fallback of the demo is always available.

Previous delivery: accepted at WeAreDevelopers World Congress 2026 - Europe.

Related sessions: I also speak on this material in a language-agnostic form. This session is the Go-native deep dive, aimed specifically at a Go audience.