Everything from AI Engineer Melbourne, distilled into a free knowledge base.
Deep primers on every topic — patterns, pitfalls, takeaways, and curated external links — so anyone can learn the material in depth, attendee or not.
Five tracks. One knowledge base.
Each track collects deep primers on real production problems — written so they stand on their own without slides, recordings, or context.
Browse the knowledge base
33 self-contained primers. Each one is a complete, free resource.
Token Town: Why Compute Strategy Is Product Strategy
In production, what matters is cost-per-task — not the price-per-million-tokens headline.
Everything Is a Factory: AI-Driven Software Pipelines
Engineers as orchestrators of agents that build, test, and ship code in parallel.
Why Your Coding Agent Forgets Everything
Context windows are not memory. Building real persistence is an architecture problem.
Mesh LLMs: Building AI From Spare Compute
A future where compute, models, and agentic capability are commodities you can route around.
Beyond Forgetful Bots: Persistent, Proactive Agent Architectures
From reactive chatbots to enduring AI partners that stick around and act on their own.
Shipping Sandboxed Workers for AI Agents
Letting users extend agents with custom code without letting their code escape.
Close Your Agentic Loop
You are the feedback loop until you build automated evaluators. Stop being the loop.
How Many Agents Are Too Many? The Hidden Cost of Multi-Agent Systems
Multi-agent designs add cost, latency, and failure modes. Here's when they're actually worth it.
Kill the God Agent: Architectural Security for Multi-Agent Systems
Prompt injection isn't a guardrail problem. It's an architecture problem.
Agent Observability at Internet Scale
What to log, how to trace multi-step agents, and how to detect drift in production.
Fixing Production Hallucinations With Evals
The demo was easy; real traffic wasn't. Build the eval stack you wish you had on day one.
The Application Layer Is the New Research Lab
Agentic systems collapse the gap between product and research. Staff for it.
Matching Models to Tasks: Routing for Cost and Quality
Don't use Opus for a Bash script. Build a routing layer.
When Agent Memory Breaks in Production
Your benchmarks pass. Then real users arrive, and memory becomes the bug.
Fail Fast, Fix Faster: Why Speed Beats Smarts in Agent Loops
A 10x faster, marginally competent model can iterate to success before a frontier model finishes thinking.
Building Frameworks That Build Systems
Don't hand-craft 200 interactive games. Build the system that builds them.
Why AI Coding Tools May Not Move Your Delivery Metrics
Coding is rarely the bottleneck. Find the real one before you tool the wrong stage.
Constitutional Prompting: Reliable Agents Without the Iteration Tax
A small set of explicit principles beats an ever-growing list of instructions.
Multi-Armed Bandits: A Scientific Shotgun for LLM Evals
A/B testing is too rigid for AI. Bandits adapt traffic in real time as evidence accumulates.
Engineering for the Agentic Web: When 50% of Traffic Is Robots
Pages aren't just for humans anymore. Design for agents reading on their behalf.
The AI Control Plane: Infrastructure as Data
When agents act on your infrastructure, your infra becomes the context window.
Your Agent Doesn't Like Your APIs
APIs designed for humans reading docs are not the same as APIs an agent can use.
Agentic Self-Healing in Production
Pipeline breaks at 2am. Nobody's watching. By morning it's fixed.
Beyond Silicon Valley: AI Governance on the Fair Go Principle
Responsible AI isn't culturally neutral. The values you build in are the values you ship.
Stop Blocking, Start Building: Governance for the Agentic Era
As AI moves from chat to act, traditional governance is too slow and looks in the wrong places.
Privacy With AI: A Practical Implementation Guide
You can have privacy and AI. Pick the technique that fits your team.
Regulatory AI: Compliance Built Into the System
Compliance and risk become embedded, intelligent capabilities — not external constraints.
Safe AI Experimentation for Non-Technical Founders
How a pre-seed team can ship and iterate fast without sacrificing safety.
Shipping AI Into Live Businesses: Lessons From the Field
90 days from idea to a thousand drivers and hundreds of customers — and where AI helped vs. hurt.
Measuring Whether Your AI Loops Actually Converge
Iteration feels like circling. The fix is making each circle measurable.
Sovereign AI: Architecting Air-Gapped Agents
On-prem hardware (e.g. NVIDIA DGX Spark) brings frontier AI back under your control.
Editing Images Faithfully Without a LoRA
Most practitioners assume style-faithful editing requires a fine-tune. It usually doesn't.
Frontier LLMs on a Desktop PC
Storage-centric inference exploits MoE sparsity to run 100B–600B+ models on consumer hardware.