🤝 "LLMs for ambiguity, deterministic agents for hard policy"—a contract-compliance ADK sample that takes role separation seriously. Title: Contract Compliance Pipeline (GoogleCloudPlatform/generative-ai) URL: An auditable demo that uses Google ADK's A2A protocol to coordinate a Python (intake) agent and a Go (validation) agent. Three highlights worth your attention. 🧠 Separating LLM from deterministic work Instead of routing everything through an LLM, ambiguous extraction goes to the LLM/parser side while hard policy enforcement runs in a deterministic Go engine. Rules like "value ≤ $500k" or "term ≤ 5 years" get checked in a repeatable, identical-every-time way. 🔌 Cross-language A2A handoff ADK's RemoteA2aAgent discovers the Go service via its Agent Card (/.well-known/agent.json) and sends a JSON-RPC 2.0 SendMessage. A Python agent (FastAPI:8000) and a Go agent (net/http:8888) collaborate using only a standard protocol. 📜 Auditable policy and artifacts Policies (value cap, term limit, minimum insurance, required exit clause, no unlimited liability, etc.) are passed as custom_policies and swappable per audit. Results are visualized with an execution trace, and the system even auto-generates compliance certificates and parameter sheets. It reads like a template you could lift straight into real regulated/review-heavy systems. #AIAgents# #GoogleADK#

# Practical and Useful Patterns with ADK Long-running tasks failing midway and restarting from scratch? That's a thing of the past! 💪 ADK's Resume Agents feature enables checkpoint-based resumption from the exact point of interruption. It supports HITL approval-pending flows too, dramatically improving agent reliability. ## 📌 Title Resume Agents — Checkpoint-Based Workflow Resumption ## 🔗 URL ## 🧩 Overview Resume Agents allows interrupted ADK workflows to continue from where they stopped rather than restarting entirely. The feature uses event logging and state preservation to track progress, enabling skipping of successful steps and seamless resumption of HITL (Human-in-the-Loop) approval-pending flows. ## 🛠 How to Use Enable resumability through `ResumabilityConfig`: Import `App` from `google.adk` and `ResumabilityConfig` from `google.adk.runtime`. Pass `resumability_config=ResumabilityConfig(is_resumable=True)` to the `App` constructor to enable checkpoint-based resumption. Also provide the `name` for the application and the `root_agent` instance. Resume by specifying the same `invocation_id`: To resume, call ` with the same `invocation_id` used during the original execution. ## 🏗 Practical Usage - **Sequential Agent**: Automatically identifies the next sub-agent to run on resume - **Loop Agent**: Continues from the last completed iteration - **Parallel Agent**: Re-executes only incomplete sub-agents - **HITL Approval Flow**: Workflows paused for human approval automatically resume after approval is granted - Custom agents extend `BaseAgentState` with checkpoints after each workflow step ## 💡 Use Cases - Recovery from failures in multi-hour data processing pipelines - Expense approval or contract review workflows requiring human sign-off - Continuing partially successful multi-step API integrations - Minimizing downtime during agent failures in production ## ⚠️ Caveats - Tools execute **at least once** and may run multiple times during resumption — ensure idempotency - Modifying workflow definitions between interruption and resume is not supported - Web UI and CLI resumption are not currently supported ## ✨ Resilient agents are a must for production workloads. Leverage Resume Agents to build workflows that gracefully survive failures! 🚀 #ADK# #AIAgent#

# Practical and Useful Patterns with ADK ## 🏢 Isolate State per Application with ADK Apps When managing multiple agent workflows, state and artifacts can bleed across boundaries. ADK **Apps** use `app_name` namespacing to completely isolate State, Artifacts, and Memory! 🏗️ ## 📌 Title Apps (Application-Level Configuration) ## 🔗 URL ## 🧩 Overview The App class is the top-level container for ADK agent workflows. It manages lifecycle, centralized configuration, and state scoping around a root agent. Key responsibilities: - **Centralized configuration**: Manage shared resources (API keys, DB clients) in one place - **Lifecycle management**: Startup/shutdown hooks for persistent resources - **State scope**: Explicit data boundaries with `app:*` prefix - **Deployment unit**: Formal unit for versioning and testing App-level settings also include Context Caching, Context Compaction, Resumability, and Plugins. ## 🛠 How to Use Import `Agent` from `google.adk.agents.llm_agent`, `App` from `google.adk.apps`, and `InMemoryRunner` from `google.adk.runners`. Create an `Agent` with `model='gemini-flash-latest'`, `name='assistant'`, and `description='General purpose assistant'`. Then create an `App` with `name="my_app"` and pass the `root_agent`. Optionally, you can also provide `plugins`, `context_cache_config`, `events_compaction_config`, and `resumability_config`. Finally, create an `InMemoryRunner(app=app)` and run with `await "Hello!")`. ## 🏗 Practical Usage **Multi-tenant SaaS data isolation:** Use different `app_name` values per tenant to achieve complete State/Artifact/Memory isolation. Define `create_tenant_app(tenant_id: str, root_agent: Agent) -> App` that creates an isolated `App` per tenant with `name=f"saas_{tenant_id}"` as the tenant-specific namespace. It includes `SecurityGuardPlugin()` for shared security and `TenantLoggingPlugin(tenant_id)` for tenant-specific logging in the `plugins` list. For Tenant A, call `create_tenant_app("tenant_a", support_agent)` and create an `InMemoryRunner` -- state is saved under `"app:saas_tenant_a:*"` and is invisible to Tenant B. For Tenant B, the same pattern applies with `"app:saas_tenant_b:*"`, keeping data completely isolated from Tenant A. **Environment-specific configuration:** For development, create an `App` with `name="myservice_dev"`, `plugins=[DebugLoggingPlugin()]`, and `events_compaction_config=EventsCompactionConfig(compaction_interval=10, overlap_size=3)`. For production, create an `App` with `name="myservice_prod"`, `plugins` containing `SecurityGuardPlugin()`, `BigQueryAnalyticsPlugin()`, and `RateLimitPlugin()`, and a tighter `EventsCompactionConfig(compaction_interval=5, overlap_size=2)` for more frequent compaction. ## 💡 Use Cases - 🏢 **Multi-tenant SaaS**: Isolate Apps per tenant to prevent data leakage entirely - 🔧 **Environment separation**: Apply different plugins and configs for dev/staging/prod - 📦 **Microservices**: Deploy and version each service as an independent App - 🧪 **A/B testing**: Run the same agent with different App configurations to compare results - 🔄 **Lifecycle management**: Centralize DB connection pool and cache init/cleanup ## ⚠️ Caveats - `app_name` is used as the namespace for State/Artifact/Memory — keep it unique and stable - Changing the App name will make past State and Artifacts inaccessible - If multiple Apps share the same root agent, ensure the agent is stateless - Separate tenant-common and tenant-specific plugins appropriately at the App level ## ✨ Closing The App class draws clear boundaries for deploying and operating ADK agents. Multi-tenant isolation, environment-specific configs, lifecycle management — designing Apps thoughtfully is the key to building scalable, secure agent applications! #ADK# #AIAgent#

# Useful but Little-Known Features of ADK 2.0 🌍 Want to build AI agents that run entirely on your own hardware, with no cloud API dependency? ADK 2.0 supports local and self-hosted model serving through LiteRT-LM, vLLM, and Ollama — enabling fully cloud-independent agent development. 📌 Title: Local & Self-Hosting with LiteRT-LM / vLLM / Ollama 🔗 URL: 🧩 Overview LiteRT-LM is a C++-based inference library optimized for edge platforms. Simply download a model with `lit pull` and start a local server with `lit serve` — then point your ADK agent to the local endpoint via the `base_url` parameter. The same pattern works with vLLM and Ollama-hosted models, giving you flexibility across different hosting environments. 🛠 How to use it With LiteRT-LM, first download the model and start the server. ```bash # Download the model lit pull gemma3n-e2b # Start local server lit serve --port 8001 ``` Then connect your ADK agent by specifying the `base_url`. ```python from google.adk.agents import Agent from google.adk.models import Gemini agent = Agent( name="local_agent", model=Gemini( model="gemma3n-e2b", base_url="http://localhost:8001", ), instruction="Process tasks using the local model", ) ``` Use the `--verbose` flag during debugging to inspect request/response details. 🏗 Building it into production ・Use LiteRT-LM on edge devices for optimized latency and data privacy ・Leverage vLLM on GPU servers for high-throughput inference ・Use Ollama for rapid development and prototyping ・Implement health checks and resource monitoring for local servers to ensure stable operations 💡 Use cases 🏥 On-premises AI in healthcare where patient data cannot leave the facility 🏭 Real-time quality inspection on factory edge devices 🔐 Data sovereignty compliance in environments handling classified information ✈️ Offline-capable agents in environments with unreliable network connectivity ⚠️ Watch out Local models may underperform compared to large cloud-hosted models. On edge devices, pay attention to memory and compute constraints when choosing model sizes. LiteRT-LM is a C++ library, so verify platform-specific build compatibility beforehand. Model updates and version management must be handled manually, unlike cloud APIs that manage this transparently. ✨ Local hosting lets you build agents that satisfy privacy, latency, and offline requirements all at once. Choose between LiteRT-LM, vLLM, and Ollama based on your deployment needs. #ADK# #AIAgent#

# Practical and Useful Patterns with ADK ## 📚 Load Knowledge On-Demand with ADK Skills Stuffing all knowledge into your agent's instructions blows up token costs. ADK **Skills** let you load workflows and knowledge on-demand — only when relevant — saving tokens while extending capabilities! 🚀 ## 📌 Title Skills for Agents ## 🔗 URL ## 🧩 Overview A Skill is a self-contained unit of functionality that an ADK agent can use to perform a specific task. It packages instructions, references, assets, and scripts, loading them only when the agent needs them. Skills follow a 3-level architecture: - **L1 (Metadata)**: `SKILL.md` frontmatter enables skill discovery - **L2 (Instructions)**: Main instructions in the `SKILL.md` body - **L3 (Resources)**: Supporting materials in `references/`, `assets/`, `scripts/` By loading only when needed, Skills optimize context window usage and minimize token consumption. ## 🛠 How to Use **Directory structure:** ``` my_agent/ skills/ code_review/ SKILL.md # Required: metadata + instructions references/ CHECKLIST.md # Detailed review checklist assets/ template.json # Review output template scripts/ # Lint execution script ``` **Python integration:** Import `load_skill_from_dir` from `google.adk.skills` and `skill_toolset` from ` along with `pathlib`. Call `load_skill_from_dir()` with the path `pathlib.Path(__file__).parent / "skills" / "code_review"` to load the skill from its directory. Then create a `skill_toolset.SkillToolset(skills=[code_review_skill])` and pass it to the `Agent` constructor via the `tools` parameter. The agent is created with `model="gemini-flash-latest"` and `name="dev_assistant"`, gaining on-demand access to the skill through the toolset. ## 🏗 Practical Usage **Skills for a DevOps agent:** ``` skills/ code_review/ SKILL.md # "Code Review Checklist" references/ CHECKLIST.md # Detailed review criteria release/ SKILL.md # "Release Procedure" references/ PROCEDURE.md # Step-by-step release flow assets/ changelog.tmpl # CHANGELOG template incident/ SKILL.md # "Incident Response" references/ RUNBOOK.md # Incident response runbook scripts/ # Slack notification script ``` The agent loads `code_review` only when asked to review code, and `release` only when asked to deploy. No need to keep all skills loaded at all times, dramatically reducing token consumption. **Inline skills (TypeScript):** ```typescript const releaseSkill: Skill = { frontmatter: { name: 'release-procedure', description: 'Standard release procedure with checklist', }, instructions: "Follow the release checklist step by step...", resources: { references: { 'checklist.md': '1. Run tests\n2. Update version\n3. Create tag...', }, }, }; const skillTools = new SkillToolset([releaseSkill]); ``` ## 💡 Use Cases - 📋 **Code review checklists**: Load detailed review criteria only when reviews are requested - 🚀 **Release procedures**: Load step-by-step deployment guides and templates only at release time - 🔧 **Troubleshooting**: Load runbooks and notification scripts only during incidents - 📝 **Document authoring**: Load type-specific templates and guidelines per document type - 🎓 **Employee onboarding**: Load relevant knowledge base sections based on questions ## ⚠️ Caveats - Skills are experimental (Python v1.25.0+, TypeScript v0.6.1+, Go v1.2.0+) - `SKILL.md` is required; include `name` and `description` in frontmatter - Skill discovery accuracy depends on description quality — write clear descriptions - Large resource files impact token consumption; keep them minimal - Be mindful of script execution permissions and security ## ✨ Closing Skills implement "load knowledge only when needed" in an elegant way. Instead of cramming everything into instructions, modularize capabilities as Skills to keep token costs low while extending your agent's abilities infinitely. DevOps, customer support, education — the pattern applies everywhere! #ADK# #AIAgent#

# Practical and Useful Patterns with ADK Sending the same system prompts and tool definitions over and over? Context Caching dramatically reduces repeated prefix token costs 💰 📌 **Title**: Context Caching 🔗 **URL**: ## 🧩 Overview Context Caching caches the static portions of context sent to the LLM (system instructions, tool definitions, etc.) to reduce repeated token costs. By configuring `ContextCacheConfig`, instead of resending the same prefix tokens with every request, the agent references cached context. The cost optimization impact is especially significant in multi-user environments where many users share the same agent with identical prompts and tool definitions. ## 🛠 How to Use Import `Agent` from `google.adk` and `ContextCacheConfig` from `google.adk.agents`. Create a cache configuration with `ContextCacheConfig(max_entries=100, ttl_seconds=3600)` to set the maximum number of cache entries and the time-to-live in seconds. Pass this `cache_config` to the `Agent`'s `context_cache_config` parameter so that the static portions of the `instruction` (your long system prompt) and `tools` definitions (e.g., `search_kb`, `create_ticket`, `escalate`) are cached, reducing repeated token costs. ## 🏗 Practical Usage **Large-scale customer support optimization:** In a customer support agent, these elements are common across all users: - System instructions (response guidelines, tone, prohibited actions) - Tool definitions (knowledge base search, ticket creation, escalation) - Few-shot examples These static contexts can amount to thousands of tokens per request. For a support bot handling 10,000 requests daily, Context Caching delivers massive token savings. **RAG pipeline optimization:** When tool definitions include knowledge base schemas and search parameter descriptions, caching these optimizes per-query costs. **Multi-tenant SaaS:** When sharing the same agent definition across multiple tenants, only tenant-specific information becomes the dynamic portion while common prompts and tool definitions are shared via cache. ## 💡 Use Cases - 💰 Cost reduction: Cut costs from repeatedly sending long system prompts - 🚀 Latency improvement: Faster prefill processing on cache hits - 👥 Multi-user optimization: Share cache across multiple users with the same prompts - 🏢 Multi-tenant: Efficiently cache tenant-common context portions - 📚 Large tool definitions: Optimize tool definition costs for agents with many tools ## ⚠️ Caveats - Context Caching depends on model provider support. Verify available models in advance - TTL too short reduces hit rates; too long consumes memory. Tune based on access patterns - Benefits are limited if system prompts or tool definitions change frequently - Caching itself may incur costs. Check provider pricing and evaluate total cost - Dynamic context (user-specific information, etc.) is not cacheable. Design clear separation between static and dynamic portions ✨ Context Caching implements "don't repeat yourself" at the infrastructure level. It delivers major cost optimization benefits in multi-user environments! #ADK# #AIAgent#

# Practical and Useful Patterns with ADK Memory enables "long-term recall" across sessions. Build agents that learn from past conversations and deeply understand each user 🧠 📌 **Title**: Memory 🔗 **URL**: ## 🧩 Overview Memory manages long-term knowledge that is searchable across sessions. While State holds data for "the current conversation," Memory accumulates "knowledge gained from past conversations" and makes it searchable via natural language. The two key APIs are: - `add_session_to_memory` / `add_events_to_memory`: Add session or event content to memory - `search_memory`: Search memory with natural language queries Backends can use vector databases like Chroma, improving agent response quality through RAG (Retrieval-Augmented Generation) patterns. ## 🛠 How to Use Import and instantiate `InMemoryMemoryService` from `google.adk.memory`. When a session ends, call `await memory_service.add_session_to_memory(session)` to store the session content in memory. To search, use `await memory_service.search_memory(app_name=..., user_id=..., query="previous network connection issues")` with a natural language query. Iterate over the returned results and access each `memory.content` to retrieve related past conversation content for use as agent context. ## 🏗 Practical Usage **Customer support scenario:** 1. User reports "My network isn't connecting again" 2. Search Memory for "network connection issues" 3. Retrieve: "User had the same issue 3 days ago, resolved by router restart" 4. Agent suggests: "Was your previous issue resolved? If the symptoms are the same, try restarting your router" This enables personalized support informed by past interaction history. **Learning assistant agent:** 1. User asks "I don't understand derivatives" 2. Search Memory to find "This user prefers visual explanations" and "Last time they understood through concrete examples" 3. Provide graph-based, example-driven explanations ## 💡 Use Cases - 🎧 Customer support: Informed responses based on past inquiry history. "Was your previous issue resolved?" - 📚 Learning assistance: Remember user learning styles and comprehension levels to choose optimal teaching approaches - 🏥 Health management: Understand trends from consultation history for continuous advice - 🛒 Personal shopper: Remember purchase history and preferences for accurate product suggestions ## ⚠️ Caveats - Storing personal information in Memory requires compliance with privacy policies and data protection regulations - Vector DB search accuracy depends on embedding model quality. Choose an appropriate model - Search costs increase as memory volume grows. Consider periodic cleanup or TTL (time-to-live) settings - `InMemoryMemoryService` loses data on process restart. Use persistent backends like Chroma in production ✨ With Memory giving agents long-term recall, you build deeper user relationships and agents that get smarter with every interaction! #ADK# #AIAgent#

# Practical and Useful Patterns with ADK 🔐 API Keys, Bearer Tokens, OAuth2, OpenID Connect, Service Accounts — ADK's Authentication seamlessly integrates any auth scheme into your tools. 📌 Title: Authentication — Tool Auth Integration 🔗 URL: 🧩 Overview ADK's Authentication consists of two components: AuthScheme and AuthCredential. It supports APIKey, HTTP Bearer, OAuth2, OpenID Connect, and SERVICE_ACCOUNT authentication methods, providing unified auth management across tools. OAuth2 supports browser flows, and `tool_context.state` enables token caching and expiry handling. 🛠 Usage Configuration examples for each authentication method. Import `AuthScheme`, `AuthCredential`, `APIKeyAuth`, `HTTPBearerAuth`, and `OAuth2Auth` from `google.adk.auth`. For API Key authentication, create `APIKeyAuth(header_name="X-API-Key")` as the scheme and `AuthCredential(api_key="sk-your-api-key")` as the credential. For HTTP Bearer authentication, use `HTTPBearerAuth()` with `AuthCredential(token="your-bearer-token")`. For OAuth2 (browser flow), define the scheme with `OAuth2Auth(authorization_url="", token_url="", scopes=["read", "write"])` and provide `AuthCredential(client_id="your-client-id", client_secret="your-client-secret")`. Using authentication in tools: For using authentication in tools, define `call_protected_api(endpoint: str, tool_context: ToolContext)`. Retrieve cached tokens via `tool_context.state.get("user:api_token")` and reuse them if not expired. When expired, call `refresh_token(tool_context)` for a new token and store it back in `tool_context.state["user:api_token"]` for caching. Use the token in an `Authorization: Bearer` header when making API requests. 🏗 Practical Patterns **Token Caching Strategy**: Use the `user:` prefix in `tool_context.state` to cache tokens within a user's session, avoiding redundant token fetches. Always implement expiry management. For token caching, define `get_or_refresh_token(tool_context: ToolContext) -> str`. Retrieve token data from `tool_context.state.get("user:oauth_token")` and check the `expires_at` field with a 60-second buffer. If the token is still valid, return the `access_token` directly. Otherwise, call `oauth_client.refresh(refresh_token=...)` to obtain a new token and store it in `tool_context.state["user:oauth_token"]` as a dictionary containing `access_token`, `refresh_token`, and `expires_at`. **Service Account Authentication**: For GCP service-to-service communication, SERVICE_ACCOUNT auth enables secure API calls without user intervention. **Multi-Layer Auth**: When using different auth methods within the same agent, configure auth per tool. Combining with OpenAPIToolset's `auth_scheme`/`auth_credential` is particularly effective. 💡 Use Cases 🔑 Third-party API authentication with API keys 🌐 User-delegated API operations via OAuth2 🏗️ GCP inter-service communication with service accounts 🔄 Token caching and automatic refresh ⚠️ Caveats - Never hardcode credentials (API keys, secrets). Retrieve from environment variables or Secret Manager. - OAuth2 browser flows don't work in server-side batch processing. Consider service accounts or client credentials flow instead. - Neglecting token expiry management leads to 401 errors from expired tokens. Implement automatic refresh with a time buffer. ✨ With properly configured ADK authentication, you can seamlessly embed secure API integration into your tools. Authentication is the foundation of agent trustworthiness! #ADK# #AIAgent#

# Practical and Useful Patterns with ADK 📜 Got an OpenAPI/Swagger spec? That's all you need to turn APIs into tools — ADK's OpenAPI Tools integrate existing REST APIs into agents with minimal effort. 📌 Title: OpenAPI Tools — Auto-Generating Tools from OpenAPI Specs 🔗 URL: 🧩 Overview ADK's OpenAPIToolset auto-generates RestApiTool instances from OpenAPI (Swagger) specifications. Each endpoint becomes an agent tool with automatic input validation. Set `auth_scheme` and `auth_credential` once, and authentication is automatically applied to all generated tools — no per-tool auth code needed. 🛠 Usage Auto-generating tools from an OpenAPI spec. Import `OpenAPIToolset` from ` and `APIKeyAuth` from `google.adk.auth`. Create the toolset with `OpenAPIToolset(spec_url="", auth_scheme=APIKeyAuth(header_name="X-API-Key"), auth_credential="your-api-key-here")`, which auto-generates tools from the spec with authentication automatically applied to all endpoints. Pass the `toolset` to an `Agent`'s `tools` list to make every API endpoint available as an agent tool. Using a local OpenAPI spec file: For local OpenAPI spec files, load the YAML with ` and pass it as `OpenAPIToolset(spec_dict=spec, base_url="")`, using the `spec_dict` parameter for the parsed dictionary and `base_url` to specify the API's base URL. 🏗 Practical Patterns **Instant Integration of Existing APIs**: If your internal microservices publish OpenAPI specs, they become agent tools without writing code. The spec's `description` fields serve as tool descriptions, so spec quality directly impacts agent accuracy. To integrate multiple APIs, create separate `OpenAPIToolset` instances for each service -- for example, a user service with `OpenAPIToolset(spec_url="https://user-service.internal/openapi.json", auth_scheme=APIKeyAuth(header_name="Authorization"), auth_credential="Bearer token123")` and an order service with its own spec URL and credentials. Pass both to the `Agent` as `tools=[user_api, order_api]`, allowing per-service access control with different authentication configurations. **Input Validation**: Automatic validation based on OpenAPI schema definitions (required, type, enum, etc.) prevents invalid API calls. **Incremental Integration**: Start by tooling only read-only GET endpoints. Verify behavior, then gradually add POST/PUT/DELETE endpoints. 💡 Use Cases 🏢 Agent integration of internal microservices 🛒 E-commerce API tooling (product search, order management) 📊 Natural language queries via data analysis API integration 🔗 Third-party SaaS API integration ⚠️ Caveats - Insufficient `description` fields in OpenAPI specs prevent the LLM from selecting the right tool. Review spec quality beforehand. - Never hardcode `auth_credential`. Retrieve from environment variables or Secret Manager. - Too many endpoints make LLM tool selection inaccurate. Configure the Toolset with only the endpoints you need. ✨ With OpenAPI Tools, your API specs become agent capabilities directly. Make the most of your existing API documentation! #ADK# #AIAgent#

🤔 "Building an AI agent isn't hard. But keeping it running in production? That's an entirely different challenge." — Every agent developer has hit this wall. Why Managed Agents Are the Next Big Thing in Agent Building Since LangChain launched in late 2022, agent development has evolved at a breathtaking pace. From the early excitement of AutoGPT, through the era of precise frameworks like LangGraph and Google ADK — and then in 2025, as models crossed a capability threshold, the fundamental pattern of "an LLM autonomously looping while calling tools" finally became real. The emergence of dedicated harnesses like Claude Code and Deep Agents marked another step toward the finished form. 🌊 But a deeper problem surfaced: sheer model intelligence isn't enough to keep agents running reliably in production. How do you build a trustworthy runtime? How do you resume a failed agent mid-run? How do you sandbox code safely? How do you design the UX for end users? Developers found themselves wrestling with infrastructure challenges that had nothing to do with the model itself. LangChain founder Harrison Chase crystallizes a year of hard-won lessons into the concept of "managed agents." He frames production agents as a three-layer stack — business logic, harness, and infrastructure — and positions Managed Deep Agents as the platform that takes ownership of that infrastructure layer. Runtime management, event streaming, sandboxes, memory, authentication, evaluation tools: everything developers once had to build themselves is now offered as a managed service. Anthropic's Claude Managed Agents and Vercel's Eve are converging on the same vision, signaling that the entire ecosystem is moving toward democratizing infrastructure. The era when agent developers can focus purely on business logic is finally within reach. #AIAgents# #LangChain#