Chapter 4: Tools in AI agents
Introduces tools as a way for AI agents to act on external systems and explains how tool use dynamically changes the context window.
After this chapter you will be able to
- Tools as external actions. Explain that tools let AI agents act in the external world by invoking APIs, running code, or interacting with files and services, rather than only shaping what an LLM knows or says.
- Dynamic tool context. Describe how tools affect the context window dynamically: initial tool definitions are present, and tool calls and execution outputs add to the context.
- Tools in the agent loop. Explain why agents need tools and how a tool result affects the next step of an agent loop.
- Tool traces as context. Distinguish tool definitions, tool calls, and tool outputs as the three kinds of content tool use can add to the context window.
- Risks of external actions. Justify why giving an agent tools requires safeguards, and name the controls identified in this section.
- Function calling execution boundary. Explain how function calling lets an agent use predefined external capabilities and separates the model’s probabilistic reasoning from deterministic tool execution.
- Two-stage tool exchange. Trace how the harness assembles context, receives a structured tool call, executes it, and makes a second model call for the final response.
- Call correlation and context cost. Explain why call identifiers match tool requests to results, including parallel calls, and why repeated tool interactions use context-window capacity.
- Tool contract and invocation. Explain why a tool definition acts as a contract between the model and code, and describe how its name, activation description, and parameter schema guide tool selection and input construction.
- Function calling tradeoffs. Explain why function calling suits agents with a known set of tools and what makes those agents harder to extend.
- Tool hallucination limits. Describe the tool-use mistakes called tool hallucination and distinguish what a schema can prevent from what it cannot judge.
- Harness validation and authorization. Explain what the harness must check before executing a function and why authorization cannot be left to the model.
- Built-in retrieval and execution. Explain that assistants may provide built-in functions without custom tools, and describe how retrieval and sandboxed code or terminal execution add useful results to an agent’s context.
- File and memory context. Distinguish file and workspace operations from memory operations as ways an agent retains context, including why deliberate memory writes are auditable.
- CLI as a general-purpose tool. Distinguish CLI tool use from schema-driven function calling: a CLI exposes a shell that accepts command lines, letting an agent use available operating-system utilities without a separate schema for each capability.
- Guarded command execution and feedback. Trace how an agent executes a shell command, how the command is gated, and how its output returns to the model so the agent can choose a subsequent step.
- CLI composition advantage. Explain how exposing a shell as one general-purpose tool can replace separate wrappers and schemas, and how models use familiar command-line utilities and help flags to compose tasks.
- Shell access security risks. Describe why shell access expands an agent’s security surface and distinguish the five risks identified here: destructive operations, privilege escalation, secret exposure, data exfiltration, and irreversible side effects.
- Layered CLI runtime controls. Describe the layered controls proposed for CLI agents, including isolation and access restrictions alongside command, approval, credential, and logging controls.
- CLI agent skill guidance. Explain why an agent skill is not required for CLI use but becomes worthwhile for repeatable procedures with consequential outcomes. Describe the command rules and safeguards such a skill can record.
- Agent protocol boundaries. Distinguish the boundaries addressed by A2A, AG-UI, LSP, and ACP in agentic systems.
- MCP context interface. Explain what MCP connects and why this chapter narrows its discussion to MCP.
- MCP’s standardized integration role. Explain that MCP standardizes how agents describe, discover, and access external capabilities without replacing the model-facing mechanism for tool use.
- Server-based context federation. Describe how independent MCP servers expose contextual information and actions through defined interfaces, separately from the agent harness.
- MCP host client server roles. Describe the host, client, and server roles, including why a host uses a separate client session for each server.
- Capability discovery and invocation. Trace how an MCP capability is discovered, selected, invoked, and returned to the model’s context.
- MCP tool invocation. Explain that MCP tools are executable operations the model can select through a client, supply with structured input, and have the server execute.
- Resources as external context. Describe the informational assets MCP resources expose and how reading them can ground an agent’s response.
- Resource and tool control. Distinguish exposing data as a resource from exposing it through a tool, including who decides when it enters context.
- Reusable server prompts. Describe how an MCP server’s prompts are retrieved and filled in, and why servers expose them.
- MCP server discovery and control. Explain how an MCP registry helps clients and developers find servers, and how enterprises can use private registries or approved catalogs to restrict agent access.
- Runtime capability approval. Explain why MCP’s discoverable, changeable tool catalog needs an approval path in enterprise deployments. Describe how reviewed server versions, tool allowlists, and catalog monitoring keep newly advertised capabilities from bypassing review.
- Tool metadata context pressure. Describe why connecting multiple MCP servers can consume the model’s context window and how a client can limit the exposed catalog.
- MCP tool security boundaries. Explain how exposed tools, misleading tool descriptions, and limited built-in scope control create security risks, and identify where permissions must be enforced.
- Function calling execution loop. Trace how the Python example exposes a local function as a tool, sends its definition with the user prompt, executes the function requested by the model, and returns the result to the model for a final answer.
- Tool results as context. Explain how the weather tool both extends what the agent can do and supplies a weather value that becomes working context for the model’s final response.
- Reusable CLI skill procedure. Explain how the workspace-analyzer skill guides a CLI-capable agent through scanning, reporting, seeking approval, and only then deleting or reorganizing files, even though the agent could run the standard commands without the skill.
- Skill intent versus enforcement. Distinguish the approval step stated by a skill from approval enforced by the harness, and describe the sandbox precaution for deletion.
- Filesystem server connection. Describe how to register the Filesystem MCP server in Goose Desktop: install Goose and Node.js, add an extension that starts the local server over STDIO with a chosen directory, and save it.
- Tool capabilities and observations. Explain what Goose and the agent each do after the connection is enabled, including how server responses affect the model's subsequent reasoning.
- Shared folder security boundaries. Justify limiting the exposed directory to a dedicated folder whose contents you control, considering both file permissions and untrusted observations.
- Browser MCP server interface. Describe how the sample server exposes browser actions to an agent: the MCP SDK handles protocol concerns, while explicitly registered tools describe their inputs and execute browser logic through Selenium.
- Browser tool security boundaries. Explain the risks of exposing browser tools and the safeguards proposed for this demonstration.
What it builds on
- External knowledge (chapter 3) · The role of external knowledge as a context source.
- The context window (chapter 1) · The idea of an LLM context window.
- AI agents (chapter 1) · The agent loop and agent harness introduced for AI agents.
- Tools (chapter 1) · Tools as a category of context source.
- Memory (chapter 1) · Memory as a source of context.
- Agent skills (chapter 2) · Agent skills as a structured way to package specialized expertise and procedural rules.
- The anatomy of a skill (chapter 2) · Assumes familiarity with an agent skill as a reusable instruction artifact.
Section by section
Introduction
Introduces tools as a way for AI agents to act on external systems and explains how tool use dynamically changes the context window.
- Tools as external actions: Explain that tools let AI agents act in the external world by invoking APIs, running code, or interacting with files and services, rather than only shaping what an LLM knows or says.
Why it matters: This distinction explains why tools add a capability beyond supplying instructions or knowledge. - Dynamic tool context: Describe how tools affect the context window dynamically: initial tool definitions are present, and tool calls and execution outputs add to the context.
Why it matters: Tool use changes the context an agent works with as it acts.
Key terms: tools, AI agents, external world, context window, tool definitions, tool call, execution output
4.1 Tools
This section explains how tools let agents act beyond the model, feed observations back into context, and introduce risks that require controls.
- Tools in the agent loop: Explain why agents need tools and how a tool result affects the next step of an agent loop.
Why it matters: This explains why tool use is part of an agent’s decision-making rather than just an extra source of information. - Tool traces as context: Distinguish tool definitions, tool calls, and tool outputs as the three kinds of content tool use can add to the context window.
Why it matters: These distinct records show how external actions and their results become context for the agent. - Three tool exposure paradigms: Distinguish function calling, CLI access, and MCP at the level of how each exposes external capabilities to an agent.
Why it matters: The shared request-and-execution pattern makes the differences between tool interfaces easier to place. - Risks of external actions: Justify why giving an agent tools requires safeguards, and name the controls identified in this section.
Why it matters: An incorrect answer and an incorrect external action have different consequences.
Key terms: tools, agent loop, agent harness, observations, context injectors, tool definitions, tool calls, tool outputs, context window, function calling
4.2 Function calling
This section explains how an agent harness turns a model’s structured tool request into external execution and a grounded response, and what that exchange costs in context.
- Function calling execution boundary: Explain how function calling lets an agent use predefined external capabilities and separates the model’s probabilistic reasoning from deterministic tool execution.
Why it matters: This distinction clarifies what the model decides and what the external capability actually does. - Two-stage tool exchange: Trace how the harness assembles context, receives a structured tool call, executes it, and makes a second model call for the final response.
Why it matters: Following both model calls shows how a tool result becomes evidence for the agent’s answer. - Call correlation and context cost: Explain why call identifiers match tool requests to results, including parallel calls, and why repeated tool interactions use context-window capacity.
Why it matters: Tool calls need both reliable result matching and room in the context window as an agent continues working.
Key terms: function calling, external capabilities, probabilistic reasoning, deterministic execution, agent harness, tool definitions, structured tool call, typed arguments, message history, grounded response
4.2.1 Tool definitions as contracts
This section explains how a structured tool definition acts as a contract that lets an agent choose a tool, supply valid inputs, and interpret its results or errors.
- Tool contract and invocation: Explain why a tool definition acts as a contract between the model and code, and describe how its name, activation description, and parameter schema guide tool selection and input construction.
Why it matters: A clear contract helps the agent choose the intended action and provide inputs the code can accept. - Tool results and error contracts: Describe how output schemas and actionable error contracts help the agent handle a tool call’s response, including a failed call.
Why it matters: The contract remains useful after invocation because the agent must make sense of both results and failures.
Key terms: tool definition, operational contract, unique name, activation description, parameter schema, output schema, actionable error contract, structured error responses
4.2.2 Strengths, limits, and failure modes
This section explains where function calling works well, why schemas do not prevent tool-use mistakes, and what safeguards the execution harness needs.
- Function calling tradeoffs: Explain why function calling suits agents with a known set of tools and what makes those agents harder to extend.
Why it matters: It helps you judge when a fixed tool set is an advantage and when it becomes a constraint. - Tool hallucination limits: Describe the tool-use mistakes called tool hallucination and distinguish what a schema can prevent from what it cannot judge.
Why it matters: A valid-looking tool call can still be the wrong action. - Harness validation and authorization: Explain what the harness must check before executing a function and why authorization cannot be left to the model.
Why it matters: The model's proposed action must pass checks outside the model before it can affect a system. - Side-effect and audit safeguards: Describe the additional controls for write operations and execution, and what an auditable tool trace records.
Why it matters: These controls limit damage from writes and retries and leave a record of what happened.
Key terms: function calling, schema-driven, tool definitions, tool hallucination, schema, malformed calls, harness, validation, authorization, execution path
4.2.3 Built-in functions in AI agents
This section explains how built-in agent functions help acquire, update, preserve, and manage context without developer-defined tools.
- Built-in retrieval and execution: Explain that assistants may provide built-in functions without custom tools, and describe how retrieval and sandboxed code or terminal execution add useful results to an agent’s context.
Why it matters: These built-in functions give agents information and computed results they need not generate from the model alone. - File and memory context: Distinguish file and workspace operations from memory operations as ways an agent retains context, including why deliberate memory writes are auditable.
Why it matters: The distinction clarifies where an agent keeps working artifacts versus information meant to outlast the interaction. - Clarification and action control: Describe how built-in interaction controls let an agent seek missing information or confirmation and pause before a sensitive action.
Why it matters: An agent sometimes needs input or a checkpoint before it can proceed appropriately.
Key terms: built-in functions, information retrieval and browsing, code execution and terminal access, sandboxed environments, file and workspace operations, persistent, inspectable context objects, memory read and write operations, interaction control and clarification, control primitives
4.3 Command-line interface
This section explains how a CLI gives an AI agent broad tool access through a shell, with guarded command execution and output fed back into the model’s context.
- CLI as a general-purpose tool: Distinguish CLI tool use from schema-driven function calling: a CLI exposes a shell that accepts command lines, letting an agent use available operating-system utilities without a separate schema for each capability.
Why it matters: This distinction explains why a shell can give an agent access to many different utilities. - Guarded command execution and feedback: Trace how an agent executes a shell command, how the command is gated, and how its output returns to the model so the agent can choose a subsequent step.
Why it matters: The returned output lets the agent react to what actually happened, while the sandbox and policy guard command execution.
Key terms: CLI, schema-driven function calling, shell, command line, sandbox, command policy, human approval, harness, standard output, error messages
4.3.1 Strengths and failure modes
This section explains why a shell simplifies agent tooling, what risks shell access creates, and which runtime controls can reduce them.
- CLI composition advantage: Explain how exposing a shell as one general-purpose tool can replace separate wrappers and schemas, and how models use familiar command-line utilities and help flags to compose tasks.
Why it matters: It explains the appeal of giving an agent a shell despite the risks that follow. - Shell access security risks: Describe why shell access expands an agent’s security surface and distinguish the five risks identified here: destructive operations, privilege escalation, secret exposure, data exfiltration, and irreversible side effects.
Why it matters: The same broad access that makes a shell useful can let an agent cause damage or disclose data. - Layered CLI runtime controls: Describe the layered controls proposed for CLI agents, including isolation and access restrictions alongside command, approval, credential, and logging controls.
Why it matters: No single safeguard addresses every way a shell-enabled agent can cause harm.
Key terms: CLI tool architecture, composition, shell, wrappers and schemas, --help, security surface, destructive operations, privilege escalation, secret exposure, data exfiltration
4.3.2 CLI tools in agent skills
Explains when agent skills are useful for guiding an agent’s use of command-line tools and what those skills record.
- CLI agent skill guidance: Explain why an agent skill is not required for CLI use but becomes worthwhile for repeatable procedures with consequential outcomes. Describe the command rules and safeguards such a skill can record.
Why it matters: This helps distinguish routine CLI use from procedures that benefit from explicit instructions and safeguards.
Key terms: command-line tools, agent skills, permitted commands, confirmation
4.4 Agent protocols
This section maps the communication boundaries in agentic systems to five protocols and identifies MCP as the chapter’s focus.
- Agent protocol boundaries: Distinguish the boundaries addressed by A2A, AG-UI, LSP, and ACP in agentic systems.
Why it matters: Identifying the boundary helps distinguish protocols that might otherwise seem interchangeable. - MCP context interface: Explain what MCP connects and why this chapter narrows its discussion to MCP.
Why it matters: MCP addresses an agent’s access to tools and external resources, rather than the peer-agent or user-interface boundaries.
Key terms: A2A, AG-UI, LSP, ACP, model context protocol, MCP, standardized context interface
4.5 Model context protocol
Introduces MCP as a standard for connecting agents to external capabilities and explains its role as a context federation layer.
- MCP’s standardized integration role: Explain that MCP standardizes how agents describe, discover, and access external capabilities without replacing the model-facing mechanism for tool use.
Why it matters: This distinction separates how a model uses a tool from how an agent connects to external capabilities. - Server-based context federation: Describe how independent MCP servers expose contextual information and actions through defined interfaces, separately from the agent harness.
Why it matters: Separating capabilities from the agent harness makes external context and actions available through defined interfaces.
Key terms: MCP, open protocol, model-facing mechanism for tool use, context federation layer, independent servers, agent harness, operational context
4.5.1 MCP architecture
Explains MCP’s host-client-server architecture, how clients communicate with servers, and how discovered capabilities become available to an agent.
- MCP host client server roles: Describe the host, client, and server roles, including why a host uses a separate client session for each server.
Why it matters: These roles clarify which component connects the agent to each external capability. - MCP connection transports: Distinguish the messaging and transport described for local versus remote MCP connections.
Why it matters: The connection type determines how an MCP client communicates with its server. - Capability discovery and invocation: Trace how an MCP capability is discovered, selected, invoked, and returned to the model’s context.
Why it matters: This sequence shows how an external capability becomes useful in the agent’s next step or answer. - Decoupled capability expansion: Explain why registering a new MCP server can give an agent access to new functionality without redeployment.
Why it matters: Discovery makes adding capabilities less dependent on changing and redeploying the agent.
Key terms: MCP host, MCP client, MCP server, one-to-one session, transport layer, JSON-RPC, STDIO, Streamable HTTP, discovery, single catalog
4.5.2 MCP servers
This section explains the three capabilities MCP servers expose—tools, resources, and prompts—and how each shapes an agent’s actions or context.
- MCP tool invocation: Explain that MCP tools are executable operations the model can select through a client, supply with structured input, and have the server execute.
Why it matters: This distinguishes an operation an agent can perform from information it can read. - Namespaced tool routing: Explain why fully qualified tool names help in deployments with multiple MCP servers.
Why it matters: Names help the model distinguish which server’s capability fits a request. - Resources as external context: Describe the informational assets MCP resources expose and how reading them can ground an agent’s response.
Why it matters: Resources give an agent a way to base an answer on external records rather than its existing context alone. - Resource and tool control: Distinguish exposing data as a resource from exposing it through a tool, including who decides when it enters context.
Why it matters: The distinction determines who controls when data is supplied and when the model can choose an action. - Reusable server prompts: Describe how an MCP server’s prompts are retrieved and filled in, and why servers expose them.
Why it matters: Server-provided prompts let clients offer consistent, well-formed requests without each inventing domain-specific wording.
Key terms: tools, name, description, parameters, output schema, fully qualified names, namespacing, routing signals, resources, resource type
4.5.3 MCP server ecosystem
This section explains how MCP server registries help people discover servers and how enterprises can limit which servers agents may use.
- MCP server discovery and control: Explain how an MCP registry helps clients and developers find servers, and how enterprises can use private registries or approved catalogs to restrict agent access.
Why it matters: A shared catalog makes servers easier to find while giving enterprises a way to limit agent access.
Key terms: MCP Registry, private registries, approved catalogs, server metadata
4.5.4 MCP in production environments
This section explains why MCP’s runtime flexibility needs controls for security, context use, permissions, and reliability in production.
- Runtime capability approval: Explain why MCP’s discoverable, changeable tool catalog needs an approval path in enterprise deployments. Describe how reviewed server versions, tool allowlists, and catalog monitoring keep newly advertised capabilities from bypassing review.
Why it matters: A discoverable tool is not necessarily an approved tool. - Tool metadata context pressure: Describe why connecting multiple MCP servers can consume the model’s context window and how a client can limit the exposed catalog.
Why it matters: Limiting exposed tools preserves context for the agent’s task. - MCP tool security boundaries: Explain how exposed tools, misleading tool descriptions, and limited built-in scope control create security risks, and identify where permissions must be enforced.
Why it matters: Making a tool discoverable does not make it safe or appropriately permissioned. - Production reliability safeguards: Describe how variable tool-call latency and failures affect an MCP agent, and name the operational safeguards the section recommends.
Why it matters: Production agents need to remain observable and usable when tools are slow or fail.
Key terms: server discoverability, dynamic capability injection, allowlist, approved baseline, context window pressure, tool definitions, JSON schemas, private registry, tool shadowing, scope control
4.6 Hands-on
Introduces hands-on exercises on tools and agent skills and suggests four elements to watch for in each example.
4.6.1 Function calling with an OpenAI model
Shows a basic OpenAI function-calling loop and explains how a tool result changes the context used for the final answer.
- Function calling execution loop: Trace how the Python example exposes a local function as a tool, sends its definition with the user prompt, executes the function requested by the model, and returns the result to the model for a final answer.
Why it matters: It separates the model’s request to use a tool from the application’s execution of that tool. - Tool results as context: Explain how the weather tool both extends what the agent can do and supplies a weather value that becomes working context for the model’s final response.
Why it matters: The returned value matters because the model can use it when composing its answer.
Key terms: function calling, tool definition, execution loop, weather value, working context, final response
4.6.2 CLI with an agent skill
Shows how an agent skill gives a CLI-capable agent a reusable, reviewed workflow while leaving safety enforcement to the harness.
- Reusable CLI skill procedure: Explain how the workspace-analyzer skill guides a CLI-capable agent through scanning, reporting, seeking approval, and only then deleting or reorganizing files, even though the agent could run the standard commands without the skill.
Why it matters: A skill makes the intended terminal workflow reusable instead of leaving the agent to reconstruct it for each request. - Skill intent versus enforcement: Distinguish the approval step stated by a skill from approval enforced by the harness, and describe the sandbox precaution for deletion.
Why it matters: Written instructions alone are not a reliable safeguard for destructive CLI actions.
Key terms: skill, CLI-capable agent, reusable procedural context, workspace-analyzer skill, SKILL.md, sandboxed working directory, harness, approval step
4.6.3 Using an existing MCP server
The section shows how to connect Goose Desktop to an existing Filesystem MCP server, use its file capabilities, and limit the security risks of the shared folder.
- Filesystem server connection: Describe how to register the Filesystem MCP server in Goose Desktop: install Goose and Node.js, add an extension that starts the local server over STDIO with a chosen directory, and save it.
Why it matters: This is how the example adds filesystem access to an existing agent. - Tool capabilities and observations: Explain what Goose and the agent each do after the connection is enabled, including how server responses affect the model's subsequent reasoning.
Why it matters: It connects a tool operation to the context the model uses next. - Shared folder security boundaries: Justify limiting the exposed directory to a dedicated folder whose contents you control, considering both file permissions and untrusted observations.
Why it matters: Choosing the shared folder limits both what the agent can change and what untrusted content it may encounter.
Key terms: Goose Desktop, Filesystem MCP Server, extensions, STDIO, MCP client, capabilities, observations, model context, untrusted input, sandboxed folder
4.6.4 Implementing a custom MCP server
Shows how a minimal MCP server exposes browser tools to an agent, how to run and inspect it, and why its interface and security boundaries matter.
- Browser MCP server interface: Describe how the sample server exposes browser actions to an agent: the MCP SDK handles protocol concerns, while explicitly registered tools describe their inputs and execute browser logic through Selenium.
Why it matters: The tool definition is what lets an agent use a capability without being coupled to its implementation. - Browser tool security boundaries: Explain the risks of exposing browser tools and the safeguards proposed for this demonstration.
Why it matters: Even a small browser tool can give an agent access to sensitive sites and hostile content. - Server startup and inspection: Describe how the JavaScript example is started and how its exposed capabilities can be checked manually.
Why it matters: Manual inspection checks what the server actually exposes before an agent relies on it. - Tool integration boundaries: Distinguish where function calling, an agent skill, and MCP place a tool, and explain why MCP tool definitions matter at the wider boundary.
Why it matters: The integration boundary explains why an MCP tool’s description and schema must communicate its capability clearly.
Key terms: MCP server, context gateway, MCP SDK, tool schemas, Selenium, transport layer, get_browser_text, navigate_url, untrusted input, allowlist
4.7 Summary
Where this is used later
- Memory (chapter 5) · Tools let agents act and receive feedback during task execution.
- Context management (chapter 7) · Repeated growth of active context motivates context management.
- AgentOps (chapter 9) · Introduces tool definitions as contracts.
- Amazon Bedrock AgentCore (chapter 10) · Tool schemas are part of how tools are presented to a model.
- Memory vs state (chapter 5) · The distinction between inspectable files and explicit memory operations supports discussion of retained information.
- Human-in-the-loop (chapter 9) · Requests for confirmation and pauses before sensitive actions provide a basic interaction-control capability.
- Interoperability protocols (chapter 7) · The later protocol discussion builds on which interaction each protocol addresses.
- Interoperable context (chapter 12) · The earlier discussion of protocols for connecting agents and tools.
Concepts explained in this chapter
- MCP serverAn MCP server is a software component that exposes capabilities or information to AI applications through the Model Context Protocol.
- toolA tool is a callable capability outside a language model that an AI system can use to obtain information or perform an operation.
- MCP resourceA data or information item that a Model Context Protocol server makes available to an AI application.
- mcp promptAn MCP prompt is a reusable, parameterized message or sequence of messages that an MCP server exposes for a client to retrieve.
- mcp clientA connector component that maintains a connection with an MCP server and translates between host operations and MCP requests and responses.
- tool useTool calling is a model capability for requesting that an external tool or operation be invoked.
- MCPThe Model Context Protocol is a protocol that enables external servers to expose tools, resources, and prompts to AI applications.
- command-line interfaceA command-line interface is a text-based interface through which users interact with a computer program by entering commands.
- tool descriptionA tool definition specifies a tool's name, purpose, and expected arguments so a system can determine how to invoke it.
- agent skillA reusable set of instructions and resources that extends an agent's capabilities for a specialized workflow.
- agent harnessA harness is a surrounding system of guides, tools, constraints, and feedback loops that shapes an AI agent's behavior within an environment.
- AI agentAn AI agent is a system that pursues goals by interpreting tasks, planning actions, using resources, and adapting its behavior with limited human intervention.
- validationValidation checks data or operations against expected requirements before further processing.
- A2AA2A is an open protocol standard for interoperability and context exchange between independent agentic applications.
- schemaA schema is a formal specification of the permitted structure, fields, and constraints of data or outputs.
- sandboxingExecution of generated code or commands within a restricted environment that limits their access and effects.
- tool resultA tool output is information returned by a tool after it runs, such as a response, computed value, or command result.
- working contextModel context is the information available to a model during inference that influences its output.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
