Stop Rewriting Boilerplate: Build AI Coding Agents on zot's Plumbing

• Introduction about the reality of building AI coding agents
• What makes zot different
• The building blocks
• Real-world use cases for custom harnesses
• Getting started

Let's be honest: building an AI coding agent from scratch is mostly a lesson in frustration. Between parsing streaming responses, wrestling with provider authentication, defining tool schemas, and implementing file sandboxes, you barely have time to think about what your agent should actually do. The interesting stuff—the logic that makes your agent unique—gets buried under a mountain of plumbing code that every single project has to implement.

This is the problem zot tackles head-on. Instead of giving you another black-box AI agent to configure, zot hands you its internal components as importable Go packages. You pick what you need, ignore what you don't, and write a working harness in roughly a hundred lines of code.

The 90/10 Problem in AI Development

If you've ever tried to build even a basic coding agent, you've probably noticed this imbalance. The actual value proposition of your agent—how it analyzes code, what workflow it implements, what persona it adopts—represents maybe 10% of the code you end up writing. The other 90%? Streaming protocol parsing, provider authentication, tool definitions, sandboxing, system prompts. Infrastructure that every AI project needs but nobody wants to build twice.

zot's approach inverts this entirely. The project ships battle-tested Go packages for all that plumbing, organized under clean interfaces. You import the provider client, the agent loop, the tool registry—whatever your harness needs—and start building your actual agent logic immediately.

Four Blocks, Endless Possibilities

The architecture that makes this work is elegantly simple. Every zot-based agent comes together from four core components:

Provider Client — Connect to Anthropic, OpenAI, Gemini, or any other supported model through a unified interface. Switching between providers is literally a one-line change because zot normalizes everything: streaming responses, tool calls, usage metrics. Your agent code stays the same whether you're using Claude or GPT-4.

Tool Registry — This is where your agent's personality emerges. zot comes with ready-made tools for reading files, writing content, executing bash commands, and editing code. But adding your own is just implementing an interface and registering it. The model sees a clean JSON schema and can invoke your custom tool like any built-in one.

System Prompt — The persona. The context. The instructions that tell the model what kind of agent it should be. zot provides helpers for building sane defaults, but you're free to craft exactly the system prompt your use case demands.

Agent Loop — The orchestration layer that ties everything together. It handles the request/response cycle, parses tool calls, executes registered tools, feeds results back to the model, and loops until completion or step limit.

That's it. Four blocks, and your agent is running.

Why Build Your Own Harness?

zot includes a full interactive TUI out of the box, so you might be wondering why you'd bother writing a custom harness at all. Fair question. Here's when custom makes sense:

Batched and CI-Friendly Workflows — Interactive TUIs are great for exploration, but what about automated tasks? A custom harness can accept a prompt, run to completion, and exit. Perfect for CI pipelines that need code review, test generation, or documentation updates on every pull request.

Embedded Agent Behavior — Want agent capabilities inside a larger Go program? A custom harness gives you programmatic control. Your main application calls the agent, receives structured results, and continues with its own logic.

Locked-Down Tooling — The interactive TUI exposes a flexible set of tools. A specialized harness can restrict the toolset and sandbox to exactly what a specific task needs—no more, no less.

Frozen Personas — Sometimes you don't want configuration. A custom harness can hard-code a system prompt and toolset for a specific purpose, turning your agent into a reliable, repeatable tool rather than a general-purpose chatbot.

Making It Yours

The real power here isn't just saving time on boilerplate. It's owning your agent's behavior completely. When you build on zot, you get access to the same battle-tested infrastructure that powers its interactive TUI, but you control every aspect of the user-facing interface. You can build a CLI with specific output formats, a webhook that receives requests and returns results, a background service that monitors repositories, or a completely custom TUI with your own visual language.

Every line of code you write is about your product, your workflow, your differentiation. Not about reimplementing streaming parsers.

Getting Started

If you're a Go developer curious about AI agents, zot represents the lowest-friction path to building something real. The four-block skeleton I described earlier is all you need to start experimenting. Register the tools you want, write a system prompt, run the agent loop.

You can have a working prototype before your coffee gets cold. And from there, every addition is about what makes your agent yours.

The AI coding agent space is still young enough that most projects are solving the same foundational problems independently. zot lets you skip that phase and jump straight to the interesting work: figuring out what your agent should do, not how it should stream responses.

That's a trade worth making.

Ready to build? Check out the zot project and explore how you can compose its components into something that fits your vision. The plumbing is handled—now go make it interesting.