1290 posts · Page 64 of 108. ← Blog
Post 23 of 26 in "Google ADK, Concept by Concept" — how a planner turns one-shot answers into inspectable plan-then-act reasoning.
Structuring an agent's reasoning: planners that make the model plan-then-act (ReAct-style), the built-in thinking feature, and how a planner improves multi-step tool use over naive prompting.
The higher-level building blocks LangGraph stacks on top of the graph engine — pausing for a human, running an agent loop, calling tools, and fanning out dynamically.
The building blocks on top of the core graph: interrupt() to pause for human input, create_react_agent and ToolNode for tool-using agents, and the Send API for dynamic parallel fan-out with a reducer fan-in.
The final lesson: a recipe agent whose JSON replies are turned into trackable state snapshots by a middleware, so the client can render the recipe as it evolves.
The server side of AG-UI state management: middleware emits a DataContent state snapshot from the model's JSON so the client can adopt shared state across turns.
Seven patterns that turn a bare model call into production agent infrastructure — each written first as offline Go behind an interface, so the leap to Azure is a swap, not a rewrite.
Seven patterns that turn a bare model call into production agent infrastructure, each written first as offline Go behind an interface (the seam) so the leap to Azure is a swap, not a rewrite.
Every data-driven engineer knows the phrase "correlation is not causation," and almost everyone violates it anyway — in A/B test readouts, in metric dashboards, in ML models used to make decisions. The gap between "these move together" and "this causes that" is where enormous amounts of money and effort get wasted on changes that don't work. Causal inference is the discipline of crossing that gap rigorously, and this series builds it from first principles for people who build systems.
Everyone knows 'correlation is not causation' and violates it anyway — in A/B readouts, dashboards, and ML used to drive decisions. The real difference (observing vs intervening), the three reasons correlation appears without causation (reverse causation, confounding, selection), and why it's an engineering problem.
Financial statements tell you what already happened; budgets and forecasts are how a business reasons about what's going to happen — and that forward view is where finance stops being accounting and starts being strategy. A forecast is a model of the future you can steer by: it tells you when you'll run out of cash, whether a plan is affordable, and what happens if things go better or worse than hoped. For engineers, it's a familiar idea in unfamiliar clothes — building a model, running scenarios, and updating on new data.
Financial statements tell you what already happened; budgets and forecasts are how a business reasons about what's going to happen — and that forward view is where finance stops being accounting and starts being strategy. For engineers, it's a familiar idea in unfamiliar clothes: building a model, running scenarios, updating on new data.
Turning geography, product, channel, and behavior into a single defensible number — and a due-diligence tier a regulator can follow.
Building a customer risk-rating model: risk factors, weighting, thresholds to due-diligence tiers, and explainability for regulators.
An agent can tighten a workload's policy, or claim a tool the workload never mentioned — but it can't loosen an explicit forbid. Here's the resolution rule.
An agent can tighten a workload's policy or claim a tool it never mentioned, but it can't loosen an explicit forbid. The subtlety everyone botches: an explicit forbid is a floor, while silence is an absence a tighter layer may fill.
How ADK closes the write-code, run-it, read-the-output loop — and why "unsafe" is a warning, not a typo.
Letting an agent write and run code: built-in and container-based code executors, safe sandboxed execution, how results flow back into the conversation, and the security tradeoffs.
How a checkpointer turns a graph run into something you can stop, reload, and replay from any point in its history.
A checkpointer saves state at every superstep boundary, so a run can pause, resume on a thread_id, and even fork from an earlier checkpoint (time-travel). This is the foundation human-in-the-loop is built on.
The server hosts an agent with one approval-gated tool — the model may propose calling it, but the framework refuses to run it until a human on the other end says yes.
The server side of AG-UI human-in-the-loop: gate a tool with tool.ApprovalRequiredFunc so the server suspends the run and resumes on the client's decision.
Interpretability has a toolbox — intrinsic models, feature importance, LIME, SHAP, counterfactuals, saliency maps — but knowing the tools isn't the same as using them wisely. The real skill is matching the method to the need, reading explanations with appropriate skepticism, and avoiding the traps that turn interpretability into false confidence. This closing post is the practical judgment the series was building toward: how to actually do interpretability without fooling yourself.
Knowing the tools isn't using them wisely. Matching the method to the need (model, level, audience), the traps that cause false confidence (explanations aren't truth, explanation isn't causation, plausible isn't correct, interpretability-washing), and the skepticism that separates genuine understanding from a rubber stamp.