Harnessing Agentic AI: Build Tools That Build Code

Note: It's mandatory to fill this google form https://forms.gle/nTa2fACdWQpRpR5WA along with the RSVP. Both RSVP and filling the google form are mandatory.

The model is only half the agent. Build the other half, the loop, the tools, the guardrails and make your own coding agent that reads, plans, edits, tests, and repairs its way to a verified pull request. No API key required. All on your machine.

"An LLM proposes. The environment decides." — come build the environment.

What you'll walk away with

By the end of this session, you will have built a working agentic AI coding agent from scratch, one that inspects an unfamiliar repository, searches code, plans, edits, runs tests, observes its own failures, and repairs its patch until it produces a verified git diff. The entire core track runs fully offline, on your own machine, with zero API keys and zero cloud spend.

You won't learn to use Claude Code or Codex. You'll learn to build what's under them.

We tear the covers off today's most-hyped AI coding tools and reveal the engineering that actually makes them work: the agent harness. An LLM is only one swappable component. The real magic and the real engineering lives in the harness around it i.e., the agent loop that decides when to think, when to call a tool, and when to stop; the tool registry that turns natural language into safe, auditable actions; context engineering that keeps the model focused inside a token budget; and guardrails that keep the whole thing from going off the rails.

What we build, module by module:

• The agent loop — the while model_wants_tools() core that powers every agentic AI system, from Claude Code to OpenAI Codex
• Agentic AI tools — read, search, edit, shell, git, and a unified-diff applier that refuses to guess
• Plan → edit → patch — structured planning artifacts and surgical, review-ready changes
• Self-repair — an evidence classifier and flail guard so the agent verifies, diagnoses, and fixes its own mistakes
• Context engineering — repo maps, AGENTS.md instructions, compaction passes, and token-budget discipline
• Extensibility — skills, hooks, MCP-style tool wiring, and least-privilege subagent delegation
• Guardrails & sandboxing — deny/approve policy at a single choke point, plus prompt-injection defusal

The stack, honestly:

The harness core is pure Python stdlib, zero runtime dependencies, proving that an agent is a loop, not a framework. It speaks the same shapes as the big players: Anthropic and OpenAI compatible APIs are drop-in providers, and an optional local LLM track (Ollama + open-weights Qwen) runs the whole thing 100% on your GPU, no internet required.

Who this is for:

Backend, platform, and full-stack engineers; SREs who want agents to fix what they monitor; ML engineers ready to graduate from prompt-flavored experiments to harness engineering. Bring a laptop with Python 3.10+ and git comfort. Curiosity is the only prerequisite. Unfortunately, the internet at the venue doesn't allow everything to be downloadable, so you might have to use your mobile's hotspot if you would also wish to do along with the presenter.