Tool Use & Environment

Let the LLM produce typed calls against an external toolkit instead of producing free-form text the surrounding system has to parse.

Standardise how agents discover and call tools so that a tool written once is usable by any conformant agent.

Have the agent emit a code snippet as its action each step, executed in a constrained interpreter, instead of emitting JSON tool calls; tool composition becomes function nesting and control flow insi…

Let the model emit code, run it in a sandbox, and treat the run as the answer instead of trusting the model to compute in its head.

Let the model drive a desktop end-to-end via screenshots plus virtual mouse/keyboard tool calls instead of bespoke per-app APIs.

Design the tool surface for an LLM agent specifically, with affordances different from human-facing CLIs.

Expose websites to the agent through a structured DOM/accessibility tree plus a small action vocabulary, sitting between raw HTML and pixel-level Computer Use.

Compose a voice agent as a tightly co-located pipeline of speech-to-text, language-aware LLM reasoning, and text-to-speech, where one vendor owns all three so language and dialect propagate cleanly a…

Run agent-emitted code or actions in a contained environment with restricted filesystem, network, and process privileges.

Package author-time procedures (markdown + optional resources) the agent loads on demand for specific task types.

Let the agent grow its own toolkit by writing reusable skills that subsequent runs can call.

Order prompts so the unchanging prefix can be cached by the provider, cutting per-call cost and latency.

Cache the result of expensive deterministic tool calls keyed by their arguments so repeat calls within a session return immediately.

Split a GUI agent into a decision model that plans and recovers from errors and a grounding model that observes pixels and emits the precise action; route each subproblem to the better-suited model.

Select a small task-relevant subset of available tools per request rather than exposing the full registry to the model.

Route each incoming URL to a domain-specific crawler through a central dispatcher mapping URL patterns to registered crawler classes.

Drive a smartphone end-to-end through a small, touch-native action vocabulary (tap, long-press, swipe, type, back, home) over screenshots, as a distinct interaction surface from desktop Computer Use…

Let the agent discover available tools at runtime rather than hardcoding the tool list at agent build time.

Mine tool-call telemetry for high-probability X-then-Y transitions and fuse those pairs into a single composite tool, shrinking the planner's step count.

An interface layer connecting an agent's tool-calling protocol to heterogeneous external tools, normalizing their schemas into one the agent expects.

Build the foundational agent block as an LLM augmented with retrieval, tools, and memory that the model actively chooses to use, rather than a bare-model call.

Insert a typed boundary between the agent's clean domain model and a messy or legacy external API.

Give an agent a bounded wallet so it can settle a payment mid-request to unlock a resource — answering a payment-required challenge with a verifiable proof — instead of routing every purchase through…

Organise tools into a tree of categories so the agent first picks a branch and then a specific tool within it.

Run a framework as both MCP client (consuming external MCP servers as tools) and MCP server (publishing its own agents, tools, and workflows back over MCP) so capabilities flow both directions across…

Materialize MCP servers as a directory of typed code wrappers so the agent writes code that imports them and large tool outputs flow between calls inside the sandbox without ever entering the model's…

Split a GUI agent into three specialist models — a Policy that plans, a Localizer that grounds elements to pixels, and a Validator that judges completion — so each role uses the smallest sufficient m…

Defer loading tool schemas into the context window until a search step shows they are needed.

Maintain a single queryable catalogue of both available tools and available agents, with metadata (capability, cost, latency, quality) the agent can use to pick the right one for a task.

Before deploying an agent against an opaque app, have it explore (or watch a human demonstrate) the app, generating a per-element documentation knowledge base; at deployment, retrieve element docs to…

Use a model class specifically trained for action execution (tool calls, UI navigation, workflow steps) rather than text generation, when the workload is dominated by reliably completing actions in r…

Project heterogeneous enterprise data sources into a single Unix-like tree exposed through filesystem primitives so the agent reuses path semantics it already knows instead of learning a bespoke API…

Package each agent skill as a WebAssembly module with a capability manifest, and run it inside a Wasm runtime that enforces those capabilities, so untrusted skills cannot weaken the host's sandbox.

Train the model to learn when and how to call tools through self-supervised data, without human annotation.