“agent”
A2UI Protocol: Agent-to-UI Collaboration for Flutter Apps
A2UI is an open protocol enabling AI agents and UI frameworks to collaborate. Learn how A2UI works with Flutter GenUI to generate dynamic interfaces from agent output.
Toxicity and Safety Filters for LLM Outputs: A Hands-On Guide
Implement production-ready toxicity and safety filters for LLM outputs. Classify, filter, and sanitize harmful content before it reaches your users.
Memory-Augmented Prompts: Injecting Recall into Every Agent Turn
Transform static prompts into dynamic, memory-aware prompts that automatically inject relevant past context. Build agents that remember without being told to.
Short-Term vs. Long-Term Memory: Architecting Multi-Horizon Recall
Design agent memory systems that span multiple time horizons. Balance fast short-term context with durable long-term knowledge for effective agent recall.
Memory Pruning: Forgetting, Expiry, and Context Budgets for Agents
Agents that never forget eventually drown in irrelevant context. Learn strategies for pruning memory — TTL-based expiry, relevance decay, and budget-aware selection.
Choosing an Agent Memory Store: Vector DBs, Key-Value, and Graphs
A practical comparison of memory store backends for AI agents. Learn when to use vector databases, key-value stores, and graph databases for different memory patterns.
Conversation Summaries as Memory: Compressing Sessions for Context
Learn how to compress long conversations into concise summaries that preserve key information, reducing token usage while maintaining agent context.
Semantic Recall: Making Agent Memory Searchable with Embeddings
Transform agent memory from keyword-matching to semantic understanding. Use embeddings to let agents find relevant past experiences by meaning, not just keywords.
Long-Term Knowledge Stores: Moving Beyond Rolling Chat History
Stop treating agent memory as a sliding window. Learn how to build long-term knowledge stores that persist insights, facts, and context across thousands of interactions.
Episodic Memory in Agents: Recording Sessions as Replayable Experiences
Learn how episodic memory enables AI agents to record, store, and replay entire sessions — turning one-off interactions into reusable, learnable experiences.
Building an Agent Risk Register from the OWASP LLM Top 10
How to build a practical agent risk register using the OWASP LLM Top 10 and Agentic Top 10 — with risk scoring, mitigation strategies, and code examples.
Structured Logging for Agent Decisions: Events, Inputs, and Outputs
How to implement structured logging for AI agent systems using OpenTelemetry, AgentTrace, and production observability tools.
Interruptible Agents: Mid-Task Corrections from Users
Patterns for building interruptible agents that support mid-task corrections — state preservation, approval gates, and human-in-the-loop UX best practices.
Hybrid Search for Agent Context: Dense, Sparse, and Keyword
Why hybrid search combining dense vector retrieval and sparse BM25 is essential for agent context, with a three-stage pipeline architecture and code examples.
LLM-as-a-Judge for Agent Outputs: Strengths and Pitfalls
How to use LLMs as evaluators for agent outputs — the strengths, systematic biases, and practical debiasing strategies for production evaluation.
Handling Barge-In: Turn-Taking and Interruption for Voice Agents
How to implement barge-in, turn-taking, and interruption handling in voice AI agents — with VAD architectures, Gemini Live API patterns, and production benchmarks.
Handoff Design: Passing State and Control Between Agents
A deep dive into agent handoff patterns — how to pass state and control between agents cleanly, with SDK implementations and failure mode analysis.
Episodic Memory in Agents: Recording Sessions as Replayable Experiences
Learn how episodic memory enables AI agents to record sessions as replayable experiences, with implementation patterns using LlamaIndex and production architectures.
Tools as a Service: Exposing Internal APIs to Agents via MCP
Transform internal APIs into MCP tools that any AI agent can discover and use. Cover API-to-MCP mapping, schema generation, and multi-tenant tool exposure.
Building a Personal Research Assistant with Long-Context Agents
Learn how to build a personal research assistant using long-context AI agents that can process entire document collections, synthesize findings, and deliver structured research reports.
Transforming a Reactive LLM Chatbot into an Agentic System
An architectural roadmap for moving from a single-turn, reactive LLM chatbot to a smart autonomous agent: planning loops, multi-tiered memory, multi-agent delegation, dynamic tool retrieval, and self-healing.
Voice Agents: Building Speech-to-Text to Agent to TTS Pipelines
Turn any text agent into a voice assistant with the OpenAI Agents SDK. Learn chained STT→agent→TTS pipelines, realtime speech-to-speech, and TTS personality tuning.
Declarative Agents: Defining Your Agent Fleet in YAML
Define agents and multi-agent workflows in version-controlled YAML instead of code. Learn declarative agents and declarative workflows 1.0 in Microsoft Agent Framework.
Human-in-the-Loop Patterns for Autonomous Agent Workflows
Build approval gates into autonomous agents. Learn the approval lifecycle, dynamic policy, and pause-and-resume state with the OpenAI Agents SDK.
Guardrails for Agent Input and Output: From Validation to Policy
Screen input, validate output, and police tool calls with guardrails. Learn input, output, and tool guardrails in the OpenAI Agents SDK—and the cost of parallel vs blocking execution.
Session Persistence and Memory for Long-Running Agent Workflows
Give your agents memory that survives restarts. Learn session backends, context trimming and summarization, and compaction with the OpenAI Agents SDK.
Deep Agents: Long-Horizon Task Execution with Durable Threads
Build agents that run for hours, pause for approval, and survive crashes. Learn durable execution, delta channels, and human-in-the-loop with LangChain Deep Agents.
A2A Protocol in Practice: Cross-Organization Agent Collaboration
Connect agents built on different frameworks and owned by different teams with the Agent2Agent protocol. Learn Agent Cards, discovery, delegation, and secure cross-org collaboration.
Google ADK 2.0: Graph Workflows for Deterministic Agent Orchestration
Stop asking the LLM to do routing. ADK 2.0 graph workflows turn agent orchestration into deterministic code—cutting latency, token costs, and hallucinated execution paths.
The OpenAI Agents SDK: From Single Agent to Delegation at Scale
Learn the two core multi-agent patterns in the OpenAI Agents SDK—handoffs and agents as tools—and how to scale from a single agent to a delegating fleet of specialists.
Building Enterprise-Grade Multi-Agent Systems with the Microsoft Agent Framework
Take multi-agent systems from prototype to production with Microsoft Agent Framework 1.0. Learn graph-based orchestration patterns, checkpointing, human-in-the-loop, and deploying to Foundry Hosted Agents.
Function Calling and Structured Output for On-Device Agents with Gemma 4
Make on-device agents reliable with Gemma 4 function calling and constrained decoding. Learn structured output patterns, parse-error fallbacks, and how to build a trustworthy tool-calling loop with LiteRT-LM.
On-Device Agentic Skills in Flutter with flutter_gemma_agent
Turn your Flutter app into an on-device AI agent with flutter_gemma_agent. Learn the SKILL.md catalog, four skill execution mechanisms, two-stage discovery, and the tool-calling loop that runs fully offline.
Bringing Agentic Skills to the Edge with Gemma 4
Learn how to give on-device apps true agentic capabilities with Gemma 4, LiteRT-LM, and Agent Skills. Build multi-step autonomous workflows that plan, call tools, and act entirely on the device.
The Future of Mobile Dev: On-Device Agents and Edge AI
Explore how on-device agents and edge AI are reshaping mobile development with Gemma 4, LiteRT-LM, and Flutter. Learn the architecture, tradeoffs, and code patterns for building privacy-first agentic apps that run entirely on the device.
Building for the AI Web: llms.txt, MCP, and Agent-Friendly Sites
AI agents are the new crawlers. How to signal discoverability with llms.txt, expose capabilities via MCP server cards, control bot access, and make your site readable by machines.
Cloudflare OS: An AI Productivity Environment, Open Sourced
A deep dive into Cloudflare OS, the open-source AI productivity environment from the Workers team, covering Gadgets, Gatekeepers, Blueprints, and capability-based security.
Cloudflare OS: an Open Platform for Agents, Apps, and Work
Cloudflare OS is an open-source platform that lets everyone in your company build apps, automate work, and safely access internal systems, shaped around what your organization knows and how it operates.
Building an AI Research Assistant End-to-End
Go from a prompt to a working research assistant: ingest papers and sources, index them for retrieval, let an agent plan and answer, and surface citations you can trust.
Database Agents: Natural Language to SQL in Production
Let users ask your database questions in plain English — safely. A production guide to text-to-SQL agents: schema grounding, query validation, and read-only guardrails.
Evals for Agents: Unit Testing Multi-Step Reasoning
Agents are too expensive to test by eye. Learn how to write evals for multi-step reasoning: checkpoints, tool-call assertions, rubric scoring, and regression gates in CI.
The Agent SDK Landscape: PydanticAI vs. LangGraph vs. CrewAI
Stop choosing an agent framework at random. Compare PydanticAI, LangGraph, and CrewAI on statefulness, multi-agent design, type safety, and operational control — then pick the right tool per job.
Building a Multi-Agent System with Google ADK
Move from single-prompt chatbots to a team of collaborating agents. Use Google ADK hierarchy, workflow agents, and session state to orchestrate a research-and-write pipeline.
Building an AI Pair Programmer: From IDE Plugin to CLI
An AI pair programmer is an agent with file tools and a loop. Learn the architecture, then build a minimal CLI pair programmer in Python with Gemini function calling.
LangGraph: Stateful, Graph-Based Agent Orchestration
LangGraph turns an agent into an explicit graph of nodes with durable state. Learn StateGraph, checkpointers, thread_id, and crash-resilient execution.
Tools, Function Calling, and the Agent Execution Loop
The agent loop is a model deciding which tools to call, observing results, and iterating. Learn function declarations, tool_choice modes, and parallel calling.
LLM Application Architecture Patterns in 2026
The architecture of an LLM application is no longer one prompt to one model. Learn the RAG, agentic, and caching patterns that production teams actually ship in 2026.
How to Run Long-Running AI Tasks With Gemini Background Execution
Learn how to use Gemini Interactions API background execution to run deep research, complex reasoning, and multi-step agent tasks asynchronously, with polling, streaming reconnection, multi-turn chaining, and cancellation patterns.
Scaling Beyond the Single Agent: Distributed Gemini 3 Clusters on Kubernetes
A single agent is a request; a cluster is a service. Learn to run distributed Gemini 3 agent workloads on Kubernetes with disaggregated prefill/decode, KV-cache-aware routing, gang scheduling, and SLO-driven autoscaling.
The "Persona-Shift" Pattern: Dynamic Expert Simulation in Gemini 3
A static persona limits an agent to one role. Learn the Persona-Shift pattern: dynamic expert switching in Gemini 3 agents that lets a single model act as planner, critic, and specialist across a workflow — without persona drift.
Gemini 3 in Cyber-Defense: Real-time Threat Hunting and Automated Mitigation
Threat hunting is a reasoning problem, not a pattern-matching problem. Learn to build a Gemini 3-powered defensive agent that hunts threats across SIEM data, maps behavior to MITRE ATT&CK, and automates mitigation with human-in-the-loop gates.
Agentic Game Design: Procedural World Building with Gemini 3 Multimodal Guidance
Games are multimodal by nature: maps, sprites, audio, and physics all have to agree. Learn to build an agent that designs and builds 3D game worlds with Gemini 3, using a constrained schema compiler and a generate-see-correct vision loop.
Agents in VR/AR: Navigating 3D Spaces with Gemini 3 Native Spatial Reasoning
Spatial reasoning is what lets an agent understand the difference between "on the table" and "next to the table." Learn to build VR/AR agents that perceive 3D space with Gemini 3, ground actions with bounding boxes and trajectories, and act through WebXR.
Gemini 3 Robotics: Bridging the Gap Between Reasoning and Physical Motion
Reasoning and motion used to live in different worlds. Learn the two-brain robotics pattern: an embodied reasoning model that plans and coordinates, and a vision-language-action model that moves.
The "Long-Horizon" Task: Keeping Gemini 3 Focused Over Months-Long Projects
Long-horizon tasks outlast a single context window. Learn to beat context rot with execution-state memory, agent-managed context tools, file-centric state, and proactive memory intervention.
The "Continuous-Learning" Agent: Updating Gemini 3 Knowledge via Live Feeds
An LLMs knowledge freezes at training time. Learn the continuous-learning agent pattern: frozen base + live vector store, temporal scoring, EWC-guarded micro-adaptation, and indexes that learn from validated queries.
Building a Meta-Agent: The Gemini 3 Orchestrator of Orchestrators
A meta-agent is a higher-order agent that operates on other agents. Learn the orchestrator-of-orchestrators pattern: hierarchical planning, sub-agent split, lazy tool discovery, and Git-like execution traces.
Human-Agent Collaboration: Designing UIs for Gemini 3 "Co-Pilot" Modes
A copilot UI is not a chat UI with autonomy bolted on. Learn the seven agent UI patterns, autonomy as a design decision, approval gates that dont train users to click through, and the AG-UI/A2UI protocol stack.
Wasm-Powered Agents: Running Secure Gemini 3 Nano Logic in the Browser
Ship an entire AI agent as a single HTML file. Learn the Wasm-powered agent pattern: Pyodide vs WebLLM, sandboxing agent-generated code in WASM kernels, and wiring MCP tools from a browser tab.
The "Browser-as-a-Tool" Pattern: How Gemini 3 Agents Navigate the Visual Web
Most valuable data lives behind a browser, not an API. Learn the browser-as-a-tool pattern: the three-layer architecture, DOM vs screenshot grounding, surface contracts, and sandboxing for Gemini 3 agents.
Sustainable AI: Strategies for Token Efficiency in Long-Running Gemini 3 Loops
Agent loops compound token costs linearly with every turn. Learn six concrete strategies to cut token usage by up to 70% in long-running Gemini 3 agents.
Securing Local Agents: Sandboxing Gemini 3 Tool Execution for Enterprise Safety
A developer laptop holds years of credentials. Learn how to sandbox local Gemini 3 agent tool execution with hardened containers, gVisor, and microVMs.
Building with the Gemini Interactions API: A Developer's Guide to the New Standard
Learn how to build AI applications with the Gemini Interactions API - the new universal interface for Gemini models and agents, covering server-side state management, background execution, migration from generateContent, and best practices.
Exploring adk-server: HTTP Infrastructure for Rust AI Agents
A deep dive into adk-server, the HTTP infrastructure and A2A protocol component for the Rust Agent Development Kit (ADK-Rust).
Automating the Future of Technical Books: Introducing Publishing Studio
Discover Publishing Studio, a sophisticated multi-agent system built on ADK that automates the entire lifecycle of technical book production.
AI Red Teaming: Strengthening Security and Integrity in the Agentic Era
Learn how AI Red Teaming helps organizations proactively discover vulnerabilities, policy violations, and security risks in autonomous AI agents.
Preventing SQL Injection in AI Agents
Learn effective strategies to prevent SQL injection attacks through prompt injection in AI agent systems, including semantic layers and least privilege principles.
Mastering Agent Skill Patterns
Explore the common structural patterns for building effective agent skills, from instruction-only guides to complex hybrid systems.
Using the API Server in Google ADK
Learn how to start and use the API server in Google ADK to expose your agents through a REST API for programmatic testing and integration.
Understanding Agent Skills
Discover how Agent Skills provide a lightweight, open format to extend AI agent capabilities with specialized workflows.
Exploring Skills.sh: Enhancing AI Agents with Reusable Capabilities
Discover Skills.sh, an open-source tool by Vercel Labs for adding reusable capabilities and domain expertise to popular AI agents like Claude Code, Cursor, and Windsurf.
Building Agentic Applications with Authenticated Tools
Secure your AI agents by mastering tool authentication in the Agent Development Kit (ADK), from static API keys to complex OAuth2 flows.
Building an AI-Powered Publishing Studio with ADK: A Multi-Agent Approach
Explore how a multi-agent system built with the Agent Developer Kit (ADK) can automate and optimize the entire publishing pipeline from research to editing.
Understanding Sequential Agents in ADK
Learn how to use Sequential Agents in the Agent Development Kit (ADK) to build strict-order workflow pipelines like code development.
Efficient Memory Management: Context Compaction in the Google ADK
Discover how Context Compaction in the Google Agent Development Kit (ADK) helps manage long-running agent sessions by intelligently summarizing history to maintain performance and accuracy.
Optimizing Agent Performance: Context Caching with Gemini in the Google ADK
Learn how to leverage context caching in the Google Agent Development Kit (ADK) with Gemini 2.0+ models to significantly reduce latency and costs for token-heavy agent interactions.
No-Code AI: Building Autonomous Agents with Google ADK and YAML
Learn how to build and deploy powerful AI agents using the Google Agent Development Kit (ADK) without writing a single line of Python code, using YAML-based configurations.
Unlocking Complexity: A Guide to Multi-Agent Systems
Explore the power of Multi-Agent Systems (MAS) and how the Agent Development Kit (ADK) enables the creation of sophisticated, modular, and reusable AI applications.
Securing the Future: A Multi-Layered Approach to AI Agent Safety
Building autonomous agents requires more than just intelligence—it requires a robust safety framework. Explore the multi-layered defense strategy for securing Google ADK agents.
Building Autonomous Agents with the Google ADK
A deep dive into the architecture and capabilities of agents built with the Google Agent Development Kit (ADK), exploring skills, tools, and security.
Integrating AI Agent Skills: Filesystem vs. Tool-Based Approaches
Explore the two primary methods for integrating skills into AI agents—direct filesystem access and secure tool-based execution—and learn which is right for your project.
Advanced Agent Skill Patterns for Pydantic AI
A deep dive into advanced design patterns for creating robust, scalable, and maintainable AI agent skills with Pydantic.
Mastering Agent Skills: Patterns and Best Practices for Robust AI
Go beyond basic security. Learn the design patterns and best practices—like idempotency, the Single Responsibility Principle, and versioning—that turn simple skills into robust, enterprise-grade components.
Unlocking Agent Skills: A Guide to Secure Implementation
Agent Skills are the building blocks of powerful AI, but they can also be a source of risk. Learn how to implement them securely using input schemas, user confirmation, and diligent auditing.
Securing AI Agents: Tackling the Trust Crisis in OpenClaw
Autonomous AI agents built with frameworks like OpenClaw are powerful, but they introduce a crisis of trust. Learn how to address the core security concerns of authorization, authenticity, and accountability.
Building Intelligent Agents with PydanticAI
A deep dive into how PydanticAI helps create powerful, data-aware AI agents by leveraging Pydantic for data validation and modeling.