All About Agents

Architecture notes, system-design mental models, and governance blueprints for production AI agents.

These notes cover how production AI agents are designed, connected to real systems, and secured—from problem-first system design mental models to zero-trust governance architectures and runnable reference labs.

Episode 01

Securing the Agent-to-Database Connection

November 2026 · about 90 minutes in full

This episode follows a single request: a customer asks an agent, “What is the status of my order #104?” It starts from the top-level picture of a user, an agent and a database, and drills down hop by hop to the low-level details: which token travels on each call, which SQL runs, and whose identity the database sees. At each level it shows what can go wrong and which guardrail prevents it, so that the detailed architecture at the end still reads as one picture. That architecture brings together workload identity, gateways, engine-level access rules, private networking, human approval, and audit on Google Cloud.

What the stages add

  • Tool boundary. Fixed, parameterized queries replace model-written SQL.
  • Identity. The agent gets its own workload identity and exchanges the user’s token for a short-lived, narrowly scoped one.
  • Database. The engine enforces row- and column-level security on every query.
  • Gateways. Ingress and egress proxies authorize each call and screen content in both directions.
  • Network. Private connectivity and a data perimeter remove the routes out.
  • Writes. A human approves each change, and stored procedures make it idempotent.
  • Audit. One trace follows a request across every hop, backed by a kill switch.
  • Mapping. Each control is mapped to the OWASP Agentic Top 10 (2026) and LLM Top 10 (2025).

Each stage links to a companion reference page with full configuration. A hands-on lab is in preparation; its implementation plan is published.

Episode 02

A Mental Model for Designing Agentic Systems

November 2026 · about 30 minutes in full

When designing an agentic system, it is easy to start with an abstract sequence of agents, name what each one does, and treat every component as a black box that will figure out the rest. This episode takes that high-level sketch and follows it down to what it actually means as an architecture: where a language model belongs versus deterministic code, how the surrounding harness coordinates control flow and state, and how structured context moves from one step to the next. Using a self-healing code repository system as a reference example, it lays out a systematic, reusable way to approach agentic system design. It ends with that architecture mapped onto Google Cloud, a printable cheat sheet, and a bridge into the controls of Episode 01.

What the stages add

  • Framing and urgent containment. Deterministic controls contain live impact in seconds before any asynchronous agent runs.
  • Reliable intake. A stateless receiver and durable queue buffer bursts and acknowledge work only at completion.
  • Coordination and recovery. Transactional locks, expiring leases, fencing checks, storm breakers, and a kill switch prevent duplicate or runaway runs.
  • Opening the black boxes. Dual-LLM separation pairs a toolless Quarantined LLM with a bounded Privileged LLM, a code verifier, and a code action gate.
  • Handoffs and state. Small validated schemas replace shared chat history, while code owns operational state and post-review memory.
  • Isolation and rollout. Credential-free sandboxes contain untrusted execution, and replay evaluations gate staged rollout.
  • Cloud mapping. Every generic role maps onto Google Cloud and Agent Platform with clear standalone-service criteria.
  • Series bridge. A printable cheat sheet summarizes all questions, and the data seam plugs directly into Episode 01.
  • Governance
    Dual LLM and CaMeL, in depth.