Archive
1290 posts · Page 96 of 108. ← Blog
You can't apply AI to a system you don't understand — and the grid, for all its ubiquity, is genuinely unfamiliar territory for most engineers. It runs on physics that permit no delay and no buffer: electricity flows at the speed of light, can't be meaningfully stored at scale, and must be balanced instant by instant or the whole system destabilizes. Before exploring how AI helps, it's worth understanding how the grid actually works — because its physical constraints are exactly what make it such a demanding problem.
You can't apply AI to a system you don't understand — and the grid is unfamiliar territory for most engineers. It runs on physics that permit no delay and no buffer: electricity can't be meaningfully stored at scale and must be balanced instant by instant or the whole system destabilizes.
How the server-hosted agent can call a tool that actually runs on the client, and the one flag that makes it work.
Let a server-hosted agent call a client-side tool over AG-UI — the server sets DisableFuncAutoCall and forwards the call to the client, which runs the Go function locally.
Architecture decisions that delivered multi-million dollar savings at petabyte scale.
Architecture decisions that delivered 57% cost reduction on Tata Group's BigQuery data warehouse. The MERGE anti-pattern fix, partition strategy, capacity model, and the trust gap I'd handle differently next time.
The electrical grid is quietly becoming one of the most complex control problems humanity has ever attempted. For a century it was relatively simple: a few big, controllable power plants supplying predictable demand. Now it's millions of variable renewable sources, distributed generation, electric vehicles, and shifting demand — all of which must be balanced, second by second, or the lights go out. That explosion of complexity is turning grid operation into a data and optimization problem, and it's why AI is becoming essential to keeping the lights on in a decarbonizing world.
The electrical grid is quietly becoming one of the most complex control problems humanity has attempted. For a century it was simple: a few controllable plants supplying predictable demand. Now it's millions of variable renewable sources that must be balanced second by second, or the lights go out. That complexity is turning grid operation into an AI problem.
How an AG-UI-hosted agent runs a server-side function tool while the thin client just streams the conversation.
Give an AG-UI-hosted agent a server-side search_restaurants tool via functool while the thin SSE client just streams the reply — the tool round-trip stays invisible.
We built a small Go + Python service that parses a project's INFORMATION_SCHEMA, asks Gemini to classify each top-spending query against a catalog of anti-patterns, and recommends a rewrite. It is not a magic box; it is a pipeline that cuts the human review time per query from 20 minutes to 90 seconds.
You've been using macros since your very first Rust program — `println!` is one, and so are `vec!`, `assert_eq!`, and `#[derive(...)]`. That telltale exclamation mark, and those `#[...]` attributes, mark code that isn't a normal function call but metaprogramming: code that writes code at compile time. Macros are how Rust does the powerful, boilerplate-eliminating tricks that would need runtime reflection or code generators in other languages — all checked at compile time. This closing post of the series demystifies them.
You've been using macros since your first Rust program — println! is one, and so are vec!, assert_eq!, and #[derive(...)]. That exclamation mark marks metaprogramming: code that writes code at compile time. This closing post of the series demystifies Rust's powerful, boilerplate-eliminating macro system.
How to take the same Foundry agent from earlier lessons and serve it over the AG-UI protocol so a separate client can drive it over HTTP+SSE.
Serve an unchanged Foundry agent over the AG-UI protocol with one aguiprovider.NewJSONHTTPHandler call, then drive it from a credential-free SSE client.
Capacity-based slot reservation is the biggest single FinOps lever for predictable batch workloads, but the transition is harder than the math. Notes from sizing reservations across enterprise GCP customers.
Module 1 covered Rust's error-handling foundation — `Result`, `Option`, and the `?` operator. It works, but as programs grow, two friction points appear: defining custom error types by hand is tedious boilerplate, and propagating many different error types through `?` gets awkward. The Rust ecosystem answers with two small, near-universal crates — `thiserror` and `anyhow` — that make error handling ergonomic. Knowing which to use where is a piece of practical Rust fluency every real project needs.
Module 1 covered Rust's error-handling foundation — Result, Option, and ?. As programs grow, two frictions appear: defining custom error types is tedious boilerplate, and propagating many error types through ? gets awkward. The ecosystem answers with two near-universal crates — thiserror and anyhow — and knowing which to use where is essential Rust fluency.
How a memory ContextProvider backed by an Azure AI Foundry store lets an agent recall you in a brand-new session.
Attach a Foundry-backed memory ContextProvider that retrieves before and stores after each run, so a fresh session still recalls facts keyed by a scope.
Storage was the second-biggest line on a large-enterprise BigQuery bill. Physical-vs-logical billing and column-level retention delivered significant savings.