{
  "source_file": "0930",
  "source_platform": "Hashnode",
  "author": "Juan Carlos Olamendy",
  "title_listed": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents",
  "keywords": "",
  "domain": "大模型算法",
  "content_type": "深度技术解析",
  "is_paid_flag": "否",
  "url": "https://juancolamendy.hashnode.dev/context-engineering-in-google-adk-the-ultimate-guide-to-building-scalable-ai-agents",
  "publish_date": "2026-01-12",
  "corpus_stage": "",
  "notes": "",
  "id": "f615e1e66d0b",
  "collected_at": "2026-10-02T14:10:47",
  "title": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents",
  "body_markdown": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents\nPublished\nJanuary 12, 2026\n•\n17\nmin read\n•\nView as Markdown\nJ\nJuan Carlos Olamendy\nSenior AI Engineer | Building & Telling Stories about AI/ML Systems | Software Engineer\nYour AI agent just burned through $500 in API costs—processing the same conversation history 47 times.\nEvery developer hits this wall: agents that forget critical details mid-conversation, multi-agent systems that can't coordinate without exploding token budgets, and production deployments that collapse under real-world conversation lengths.\nThe hidden culprit? Poor context engineering.\nWhile you've obsessed over prompt engineering and model selection, your agent drowns in its own information—wasting 60-80% of its context window on irrelevant data, forgetting what matters, and costing you both money and user trust.\nGoogle's Agent Development Kit (ADK) transforms context from an afterthought into a first-class architectural primitive.\nThis guide reveals how ADK's context engineering enables you to build agents that scale to thousands of turns, coordinate across multiple specialists, and remember what matters—all while slashing your token costs by up to 80%.\nYou'll learn the exact mechanisms, patterns, and best practices that separate hobby projects from production-grade AI systems.\nWhat Is Context Engineering in Google ADK?\nContext engineering represents the systematic design and management of information flows within AI agent systems.\nIn Google ADK, context engineering goes far beyond simply passing messages to a language model. It encompasses the entire ecosystem of data, state, memory, and environmental variables that agents need to operate effectively.\nThink of context as the agent's working memory—everything it can \"see\" and \"remember\" at any given moment. This includes the current user message, conversation history, tool outputs, system state, and even references to external data sources.\nGoogle ADK treats context as a core primitive, meaning it's built into the framework's fundamental architecture rather than bolted on as an afterthought.\nThis design philosophy enables developers to build sophisticated multi-agent systems that maintain coherent state across complex workflows. The framework provides explicit mechanisms for context creation, manipulation, sharing, and optimization.\nUnlike traditional approaches where developers manually manage context through string concatenation or simple message arrays, ADK offers structured APIs for context manipulation. These APIs allow you to store data in typed objects, share state between agents, and automatically optimize context size as workflows grow.\nWhy Context Engineering Matters for Modern AI Agents\nContext engineering directly impacts three critical aspects of agent performance: reliability, scalability, and cost.\nPoor context management leads to agents that hallucinate, forget important details, or fail to coordinate with other system components.\nGoogle ADK addresses these challenges through purpose-built context engineering capabilities.\nThe Token Economics Challenge\nEvery piece of information you feed to an LLM consumes tokens, which translate directly to API costs and latency. A poorly engineered context might include redundant information, irrelevant history, or verbose tool outputs. This waste compounds quickly: a conversation with 50 turns might contain 90% irrelevant information by the time you need the agent to make a decision.\nGoogle ADK's context compaction mechanisms automatically summarize and prune information, keeping only what matters. This optimization reduces token consumption by 60-80% in typical multi-turn conversations while maintaining decision quality.\nThe Coordination Problem\nSingle-agent systems represent the simplest case of context engineering. Multi-agent systems amplify the complexity exponentially—each agent needs relevant context while avoiding information overload. Without proper context engineering, agents either lack critical information or waste resources processing irrelevant data.\nADK solves this through hierarchical context sharing and state isolation. Specialist agents work within bounded contexts, receiving only the information they need. When agents delegate tasks to sub-agents, ADK automatically manages context handoffs, ensuring continuity without bloat.\nThe Memory Dilemma\nAgents need to remember both short-term and long-term information. Short-term memory includes the current conversation and immediate workflow state. Long-term memory encompasses user preferences, historical interactions, and domain knowledge.\nTraditional approaches force developers to choose between forgetting important information or overwhelming the context window. Google ADK provides explicit memory management with session-scoped and persistent memory services. This dual-tier approach lets agents maintain working memory efficiently while accessing long-term knowledge on demand.\nContext as a Core Primitive in Google ADK\nGoogle ADK elevates context from a simple data structure to a fundamental architectural component.\nThe framework defines context as the complete bundle of information available to agents and their tools during any operation.\nThis definition captures not just messages, but the entire computational environment surrounding agent execution.\nStructured Context Objects\nADK represents context through structured objects rather than untyped strings or dictionaries. The\nToolContext\ninterface provides type-safe access to current state, memory, conversation history, and environmental variables. Developers query context using semantic keys rather than brittle index-based access.\nThis structured approach enables powerful features like automatic context validation and type checking. When you pass context between agents or tools, ADK verifies that all required fields are present and correctly typed.\nContext Composition\nComplex contexts emerge from composing simpler context fragments. An agent might start with a base context containing system configuration and user profile. As the workflow progresses, the agent adds tool outputs, intermediate results, and reasoning traces. Sub-agents inherit relevant portions of the parent context while maintaining their own isolated state.\nADK manages this composition automatically through its context propagation system. When agent A delegates to agent B, ADK identifies which context elements are relevant and creates a focused context for B. This automatic scoping prevents context pollution while ensuring agents have necessary information.\nContext Lifecycle\nEvery context object in ADK follows a defined lifecycle: creation, augmentation, optimization, and cleanup. The framework provides hooks at each lifecycle stage, allowing developers to customize context behavior. You might inject additional data during creation, filter sensitive information during sharing, or trigger compaction when context size exceeds thresholds.\nThis lifecycle model makes context engineering predictable and debuggable. Developers can trace exactly how context evolves throughout a workflow, identifying bottlenecks or inefficiencies.\nState and Memory Management: The Foundation of Context Engineering\nEffective context engineering requires sophisticated state and memory management. Google ADK provides explicit mechanisms for both short-term and long-term information storage. These mechanisms form the foundation upon which all other context engineering features are built.\nSession State: The Agent's Scratchpad\nSession state represents the agent's working memory for the current interaction. ADK provides a key-value store where agents can write and read arbitrary data during a session. This state persists across multiple agent turns within a conversation but resets when the session ends.\nSession state excels at tracking workflow progress, caching intermediate results, and maintaining conversation context. An agent might store parsed user preferences in session state, avoiding repeated parsing in subsequent turns. Or it might cache API responses, reducing redundant external calls.\nThe session state API supports structured data types, not just strings. You can store complex objects, arrays, or nested structures, making it easy to organize information logically.\nPersistent Memory: Long-Term Knowledge\nPersistent memory extends beyond individual sessions, storing information that should survive across conversations. ADK integrates with memory services that provide durable storage for user preferences, learned behaviors, and accumulated knowledge. This persistent layer enables agents to \"remember\" users and build on previous interactions.\nThe memory service API allows both structured and unstructured storage. You might store user preferences as structured JSON while storing conversation summaries as text. ADK handles serialization and retrieval automatically, presenting a unified interface regardless of underlying storage.\nContext-Memory Integration\nThe magic happens when context engineering and memory management work together. Agents automatically inject relevant memory into their context based on the current task. A customer service agent might load the customer's purchase history into context when starting a conversation. A coding assistant might load relevant code snippets from previous sessions.\nADK provides mechanisms for automatic memory retrieval based on semantic similarity. When processing a user message, the agent can query memory for related information without manually specifying what to retrieve. This semantic retrieval ensures relevant memories influence agent behavior without manual context management.\nContext Compaction: Staying Within the Window\nContext windows have limits—even the largest LLMs eventually run out of space. Google ADK addresses this fundamental constraint through sophisticated context compaction mechanisms. These mechanisms automatically summarize, prune, and optimize context to maintain relevance while respecting token limits.\nAutomatic Summarization\nADK's compaction system automatically identifies candidates for summarization. Old conversation turns, verbose tool outputs, and completed workflow stages become summarization targets. The system applies LLM-based summarization to condense these elements while preserving key information.\nThis summarization happens transparently without developer intervention. You configure summarization policies (when to summarize, how aggressive to be), and ADK handles the rest. The agent continues operating with a compact context while critical information remains accessible.\nSmart Pruning Strategies\nNot all information deserves summarization—some should simply be removed. ADK implements intelligent pruning that identifies genuinely irrelevant context elements. Dead-end reasoning traces, failed tool attempts, and redundant confirmations become pruning candidates.\nThe pruning system uses heuristics and model-driven approaches to assess relevance. It considers temporal distance (how long ago something occurred), semantic similarity (how related to current task), and structural importance (whether other context depends on it). Items that score low on all dimensions get pruned.\nIncremental Compaction\nRather than waiting until context reaches its limit, ADK performs incremental compaction continuously. As new information enters the context, the system evaluates whether anything should be compacted or pruned. This incremental approach prevents sudden, aggressive compaction that might remove important information.\nDevelopers configure compaction triggers based on multiple criteria. You might trigger compaction when context exceeds 80% of the window, after every N agent turns, or when specific events occur. Multiple triggers can work together, ensuring context stays optimized under various conditions.\nFidelity Preservation\nThe challenge with any compression is preserving fidelity—ensuring summarized context remains useful. ADK's compaction system maintains metadata about what was compressed and how. If an agent needs more detail about a summarized element, it can request the full version from memory.\nThis \"summary with drill-down\" pattern enables aggressive compaction while maintaining access to details. The agent works with concise summaries but can expand them when needed. This flexibility balances the competing demands of context efficiency and information completeness.\nMulti-Agent Context Sharing: Coordination at Scale\nMulti-agent systems represent the frontier of AI agent development. Google ADK provides purpose-built mechanisms for context sharing across multiple collaborating agents. These mechanisms enable sophisticated coordination patterns while preventing context chaos.\nContext Isolation and Boundaries\nEach agent in an ADK system operates within its own context boundary. This isolation prevents agents from accidentally interfering with each other's state. An agent can only access its own context unless explicitly granted access to shared resources.\nContext boundaries align with agent responsibilities. A database access agent maintains context about connections and queries. A natural language agent maintains context about conversation flow. These contexts remain separate unless coordination requires sharing.\nControlled Context Sharing\nWhen agents need to collaborate, ADK provides controlled context sharing mechanisms. You explicitly declare which context elements should be shared and with whom. This declarative approach makes context flow visible and auditable.\nContext sharing happens through several mechanisms. State keys can be marked as shared, making them visible to multiple agents. Events carry context payloads that subscribing agents receive. Parent agents can pass selected context to child agents during delegation.\nContext Handoffs During Delegation\nDelegation represents a common pattern in multi-agent systems. A high-level agent delegates a subtask to a specialist agent, which performs the work and returns results. ADK manages context handoffs automatically during delegation, ensuring continuity.\nWhen agent A delegates to agent B, ADK analyzes A's context to identify relevant information for B. It creates a focused context for B containing only necessary elements. When B completes its task, it returns results along with updated context state. A receives these results and integrates them into its own context.\nShared Memory and Global State\nSome information needs to be accessible to all agents in a system. ADK provides shared memory spaces for this global state. Unlike agent-specific contexts, shared memory is visible to all agents with appropriate permissions.\nShared memory excels at maintaining system-wide state like user profiles, configuration, or cross-cutting concerns. Agents read from shared memory as needed, treating it as a source of truth. Updates to shared memory propagate automatically, ensuring all agents see consistent state.\nContext Synchronization Patterns\nMulti-agent systems face synchronization challenges when multiple agents work concurrently. ADK supports several synchronization patterns for context management. The optimistic pattern allows agents to work independently, detecting conflicts at merge time. The pessimistic pattern uses locks to prevent concurrent context modification. The eventual consistency pattern allows temporary divergence, converging to consistency over time.\nDevelopers choose synchronization patterns based on their system's requirements. Systems with frequent concurrent updates might use optimistic locking. Systems where consistency is critical might use pessimistic locking. Systems that can tolerate temporary inconsistency might use eventual consistency.\nTool Integration and Context Engineering\nTools extend agent capabilities, allowing them to interact with external systems and data sources. Google ADK integrates tools deeply with its context engineering framework. This integration ensures tools receive appropriate context and contribute meaningfully to context evolution.\nTool Context Interface\nEvery tool in ADK receives a\nToolContext\nobject when invoked. This object provides the tool with access to current agent state, memory, and conversation history. Tools use this context to make informed decisions about their behavior.\nA web search tool might examine conversation history to understand query intent. A database tool might check state to see if connections have been cached. A code execution tool might retrieve relevant code snippets from memory.\nContext-Aware Tool Selection\nAgents select which tools to use based on current context. ADK supports dynamic tool selection where available tools change based on workflow state. This context-aware selection enables sophisticated tool orchestration patterns.\nAn agent might start with a broad set of tools, then narrow to specialized tools as it learns more about the task. Or it might enable tools progressively as the workflow advances through stages. Context drives these decisions, making tool usage adaptive and efficient.\nTool Output and Context Integration\nTools return outputs that become part of the agent's context. ADK provides structured mechanisms for integrating tool outputs into context. Rather than appending raw outputs, tools return typed results that ADK processes.\nThis structured approach enables automatic context optimization for tool outputs. Large outputs can be summarized automatically. Redundant outputs can be deduplicated. Tool outputs can be cached in memory for reuse.\nPS:\nIf you like this article, share it with others ♻️\nWould help a lot ❤️\nAnd feel free to follow me for more content like this.\nBest Practices for Context Engineering in Google ADK\nEffective context engineering requires both technical knowledge and practical experience. These best practices distill lessons from production ADK deployments. They help you avoid common pitfalls and leverage ADK's full capabilities.\nPractice 1: Design Context-First Architecture\nStart your agent design with context flows, not agent logic. Map what information each agent needs and where that information comes from. Identify shared state early and design boundaries around it.\nThis context-first approach prevents retrofitting context management onto existing agents. It makes dependencies explicit and reveals opportunities for optimization. Many architectural problems are actually context engineering problems in disguise.\nPractice 2: Implement Aggressive Compaction\nDon't wait until you hit context limits to think about compaction. Configure aggressive compaction from the start, monitoring for information loss. It's easier to relax compaction than to add it to a system already hitting limits.\nTest your compaction strategy with long conversations and complex workflows. Verify that agents maintain decision quality even after multiple compaction cycles. Adjust compaction aggressiveness based on these tests.\nPractice 3: Separate Hot and Cold Context\nDistinguish between frequently accessed context (hot) and rarely accessed context (cold). Keep hot context in session state for fast access. Move cold context to persistent memory or external storage.\nThis separation optimizes both performance and token usage. Agents pay the cost of loading cold context only when needed. Hot context remains immediately accessible without external calls.\nPractice 4: Use Memory Offloading Liberally\nDon't try to fit everything into active context. Offload large datasets, detailed histories, and reference information to memory. Store references in context and retrieve details on demand.\nThis pattern works particularly well for information that might be needed but probably won't be. An agent can reference available datasets without loading them into context. If the agent needs the data, it explicitly retrieves it.\nPractice 5: Specialize Agents for Context Efficiency\nCreate specialist agents that handle token-heavy subtasks in isolation. These agents consume large context internally but return concise outputs. This specialization keeps the main agent's context clean.\nFor example, a document analysis agent might process a 50-page PDF internally. It returns a structured summary to the parent agent, consuming minimal tokens in the parent's context. The parent benefits from the analysis without the context burden.\nPractice 6: Monitor Context Health\nImplement monitoring for context-related metrics. Track context size over time, compaction frequency, memory access patterns, and context sharing volumes. These metrics reveal optimization opportunities and emerging problems.\nADK provides built-in monitoring hooks that integrate with standard observability tools. Use these hooks to create dashboards showing context health across your agent fleet. Set alerts for anomalies like sudden context growth or frequent compaction failures.\nPractice 7: Test Context Boundaries\nThoroughly test context isolation between agents. Verify that agents can't accidentally access each other's private context. Test that shared context updates propagate correctly.\nContext boundary violations create subtle bugs that are hard to diagnose. An agent might work in development but fail in production due to context contamination. Automated tests for context boundaries prevent these issues.\nChallenges and Solutions in Context Engineering\nContext engineering in Google ADK solves many problems but introduces its own challenges. Understanding these challenges and their solutions helps you build more robust systems. This section explores common issues and proven mitigation strategies.\nChallenge: Context Drift\nContext drift occurs when context gradually becomes misaligned with the actual task at hand. Compaction and summarization can introduce subtle inaccuracies that compound over time. The agent ends up working with context that doesn't quite match reality.\nSolution:\nImplement periodic context validation and refresh cycles. The agent explicitly verifies key assumptions against authoritative sources. Critical information is marked as drift-resistant, exempting it from aggressive compaction. Regular checkpoints allow the agent to rebuild context from source state if drift is detected.\nChallenge: Over-Sharing\nMulti-agent systems risk sharing too much context by default. Every agent receives context it doesn't need, wasting tokens and causing confusion. The system becomes inefficient and agents make decisions based on irrelevant information.\nSolution:\nApply the principle of least privilege to context sharing. Each agent declares exactly what context it needs, receiving nothing more. Use explicit sharing rather than implicit propagation. Regular audits identify over-shared context, allowing refinement of sharing policies.\nChallenge: Memory Coherence\nPersistent memory and session state can diverge, creating coherence issues. An agent might update session state without updating persistent memory, or vice versa. Subsequent sessions start with stale memory, confusing the agent.\nSolution:\nImplement write-through or write-back policies for memory updates. Critical state changes write through to persistent memory immediately. Less critical changes batch in session state and flush at session end. Clear policies about memory ownership prevent conflicting updates.\nChallenge: Compaction Quality\nAggressive compaction risks losing important information. The summarization model might miss subtle but critical details. The agent later fails because it lacks information that was compacted away.\nSolution:\nImplement multi-tier compaction with different aggressiveness levels. Initial compaction is conservative, preserving most detail. Subsequent passes are more aggressive as information ages. Important information is tagged and protected from aggressive compaction. Failed operations trigger context reconstruction from memory.\nChallenge: Debug Visibility\nContext engineering makes debugging harder because context evolves through many transformations. A bug might result from context compaction 10 turns ago. Tracing the issue requires understanding the entire context history.\nSolution:\nEnable comprehensive context tracing in development. Log every context transformation with timestamps and causality chains. ADK's built-in tracing captures context snapshots at key points. Replay tools reconstruct context evolution, making bugs reproducible and debuggable.\nConclusion\nContext engineering in Google ADK represents a paradigm shift in how we build AI agents. By treating context as a first-class architectural concern, ADK enables agents that scale, collaborate, and maintain coherent behavior over long interactions. The framework's sophisticated mechanisms for context management, compaction, and sharing provide the foundation for production-grade agent systems.\nSuccess with ADK requires understanding that context engineering is not a one-time design decision. It's an ongoing practice of optimizing how information flows through your agent system. You must continuously monitor context health, refine compaction strategies, and improve agent coordination.\nThe best context engineering balances competing demands: keeping enough context for quality decisions while staying within token limits. ADK's tools make this balance achievable through automatic optimization, structured memory management, and intelligent compaction.\nStart small with single-agent systems to master the basics. Progress to multi-agent systems as you develop intuition for context flow. Test rigorously, measuring both agent quality and context efficiency. Monitor production systems to catch issues before they impact users.\nRemember that context engineering amplifies everything else you do with AI agents. Great prompt engineering matters little if context is poorly managed. Sophisticated tool integration fails without proper context coordination. The most advanced models can't compensate for context engineering mistakes.\nInvest time in mastering Google ADK's context engineering capabilities. Study the examples, experiment with different patterns, and measure results. Build mental models of how context flows through your specific agent architectures. This mastery will distinguish your agents from the merely functional to the truly production-ready.\nThe future of AI agents is multi-modal, multi-agent, and massively parallel. These systems will collaborate across organizations and operate over extended timeframes. Context engineering provides the foundation that makes this future possible. Google ADK gives you the tools to build that future today.\nPS:\nIf you like this article, share it with others ♻️\nWould help a lot ❤️\nAnd feel free to follow me for more content like this.\n#\nmachine-learning\n#\nllm\n#\nagentic-ai\n#\nagentic-ai-development\n#\nadk",
  "metadata": {
    "title": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents",
    "description": "Your AI agent just burned through $500 in API costs—processing the same conversation history 47 times.\nEvery developer hits this wall: agents that forget critical details mid-conversation, multi-agent systems that can't coordinate without exploding t...",
    "keywords": null,
    "author": null,
    "og:title": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents",
    "og:description": "Your AI agent just burned through $500 in API costs—processing the same conversation history 47 times.\nEvery developer hits this wall: agents that forget critical details mid-conversation, multi-agent systems that can't coordinate without exploding t...",
    "og:url": "https://juancolamendy.hashnode.dev/context-engineering-in-google-adk-the-ultimate-guide-to-building-scalable-ai-agents",
    "og:site_name": "Juan C Olamendy",
    "og:image": "https://cdn.hashnode.com/res/hashnode/image/upload/v1768240951307/86b3522c-321c-49ef-a3ef-9afb0e21508e.png",
    "og:image:width": "1200",
    "og:image:height": "630",
    "og:type": "article",
    "twitter:card": "summary_large_image",
    "twitter:creator": "https://twitter.com/juancolamendy",
    "twitter:title": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents",
    "twitter:description": "Your AI agent just burned through $500 in API costs—processing the same conversation history 47 times.\nEvery developer hits this wall: agents that forget critical details mid-conversation, multi-agent systems that can't coordinate without exploding t...",
    "twitter:image": "https://cdn.hashnode.com/res/hashnode/image/upload/v1768240951307/86b3522c-321c-49ef-a3ef-9afb0e21508e.png",
    "article:published_time": "2026-01-12T18:04:57.789Z",
    "article:author": "https://juancolamendy.hashnode.dev/@juancolamendy"
  },
  "paywall": {
    "listed_paid": false,
    "detected": false,
    "marker": "",
    "public_only": false,
    "policy": "付费/会员内容只保留页面公开可见部分，不绕过付费墙"
  },
  "crawl": {
    "success": true,
    "status_code": 200,
    "error": ""
  },
  "code_blocks": [],
  "images": [
    {
      "status": "ok",
      "url": "https://cdn.hashnode.com/res/hashnode/image/upload/v1768240951307/86b3522c-321c-49ef-a3ef-9afb0e21508e.png",
      "bytes": 2537855,
      "reused": true,
      "local_path": "attachments/f615e1e66d0b/images/000.png",
      "src": "https://cdn.hashnode.com/res/hashnode/image/upload/v1768240951307/86b3522c-321c-49ef-a3ef-9afb0e21508e.png",
      "alt": "Context Engineering in Google ADK: The Ultimate Guide to Building Scalable AI Agents",
      "downloaded": true
    }
  ],
  "audio": [],
  "videos": [],
  "links": [
    {
      "href": "https://juancolamendy.hashnode.dev/context-engineering-in-google-adk-the-ultimate-guide-to-building-scalable-ai-agents.md",
      "label": "View as Markdown",
      "type": "a"
    },
    {
      "href": "https://hashnode.com/@juancolamendy",
      "label": "J",
      "type": "a"
    },
    {
      "href": "https://twitter.com/juancolamendy",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://www.linkedin.com/in/juancolamendy/",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://juancolamendy.hashnode.dev/tag/machine-learning",
      "label": "# machine-learning",
      "type": "a"
    },
    {
      "href": "https://juancolamendy.hashnode.dev/tag/llm",
      "label": "# llm",
      "type": "a"
    },
    {
      "href": "https://juancolamendy.hashnode.dev/tag/agentic-ai",
      "label": "# agentic-ai",
      "type": "a"
    },
    {
      "href": "https://juancolamendy.hashnode.dev/tag/agentic-ai-development",
      "label": "# agentic-ai-development",
      "type": "a"
    },
    {
      "href": "https://juancolamendy.hashnode.dev/tag/adk",
      "label": "# adk",
      "type": "a"
    }
  ],
  "retry_at": "2026-10-03T08:05:34",
  "repair_version": 2,
  "repaired_at": "2026-10-14T10:50:33Z",
  "source_url": "https://juancolamendy.hashnode.dev/context-engineering-in-google-adk-the-ultimate-guide-to-building-scalable-ai-agents",
  "papers": [],
  "actual_video_files": [],
  "body_chars": 26827,
  "expected_body_images": 1,
  "discovery_status": "ok",
  "delivery_status": "ok",
  "missing_reason": "",
  "raw_html": "attachments/f615e1e66d0b/pages/source.html",
  "local_html": "attachments/f615e1e66d0b/pages/article.html",
  "body_base_path": "attachments/f615e1e66d0b/pages/",
  "body_markdown_path": "attachments/f615e1e66d0b/pages/article.md"
}