Key details

  1. Ada released code tools and the unified Tools API on August 21, 2026.
  2. Code tools run a restricted subset of Python inside an AI-agent conversation.
  3. A tool can perform deterministic logic on its own or around an external API call before returning data to the agent.
  4. Compute is limited to about five seconds per run and roughly 65 seconds end-to-end including network activity.
  5. Network access is deny-by-default and limited to allowlisted domains plus the customer’s Ada instance.
  6. Runs can make up to ten network requests with responses capped at 1 MB each; internal/metadata addresses are blocked and redirects are not followed.
  7. MCP-authored tools use a staged change-set flow, while direct Platform API writes apply without that review step.
  8. The Tools API can list, fetch, create, update and soft-delete both HTTP/API tools and code tools.
  9. Sensitive environment values are write-only and authorization headers are not returned.

What builders should take away

  1. Move exact calculations, normalization and response trimming into code tools when model reasoning would introduce unnecessary variability.
  2. Keep allowlists narrow and treat every newly permitted domain as an expansion of the agent’s data-access boundary.
  3. Use the MCP change-set path for production changes that require human review; if the Platform API is enabled, add your own approval and audit controls around direct writes.
  4. Design tools to return the smallest structured result the agent needs so you reduce token use and avoid exposing irrelevant upstream data.
  5. Check runtime limits before moving existing helper services into Ada: long jobs, large payloads, broad package dependencies or unrestricted networking will not fit this sandbox.

What changed

Ada released code tools and a unified Tools API on August 21, 2026. A code tool can run restricted Python during a conversation, either by itself or around an external API call, before returning a smaller structured result to the AI agent. Network access is deny-by-default and limited to explicitly allowed domains plus the customer’s own Ada instance. Tools can be authored through Ada’s MCP Server, where changes go through a staged change set before promotion, or written directly through the Platform API. The new Tools API exposes list, get, create, update and delete operations for both HTTP/API tools and code tools.

Why it matters

Customer-service agents often need exact arithmetic, normalization, eligibility checks or data reduction that should not be delegated to probabilistic model reasoning. Ada’s new runtime gives operators a way to put that logic beside the agent without standing up a separate microservice for every small transformation. The useful change is the combination of deterministic code, network guardrails and an API/MCP authoring path; the trade-off is that the sandbox is deliberately constrained and direct Platform API writes bypass the staged MCP review flow.

Code runs before the model consumes the result

A code tool can call an external endpoint, reshape or calculate over the response, and return only the fields the agent needs. Ada positions this for tasks such as refund calculations, code-to-label mapping, date or currency formatting and trimming large API payloads. Moving those operations into deterministic code can reduce both prompt volume and model drift.

The sandbox is intentionally narrow

Ada supports a restricted subset of Python rather than a general-purpose runtime. Runs have about five seconds of compute time and roughly 65 seconds end-to-end including network calls. Results must be simple structured values; tools cannot return files or images. Imports are limited to a small set of standard modules and classes are not supported.

Network access is deny-by-default

Code tools use Ada’s fetch mechanism and can reach only domains placed on an allowlist plus the customer’s own Ada instance. Internal and metadata addresses are blocked, redirects are not followed, and each run is limited to ten requests with a 1 MB response cap per request. Those limits reduce SSRF-style exposure and bound accidental fan-out, but operators still need to control which domains are trusted.

MCP and API authoring have different governance semantics

When a tool is authored through Ada’s MCP Server, an AI assistant can generate the code and configuration into a change set that is staged and tested before promotion. A Platform API write applies directly. Teams using both paths should make that distinction explicit in deployment policy so a convenience API does not bypass the review process they expect from MCP-authored changes.

One API now manages both HTTP and code tools

The Tools API provides a common inventory and CRUD surface for HTTP tools and code tools. Authorization headers are never returned, and sensitive environment values are write-only. That makes programmatic tool management easier, but it also turns the Tools API into a privileged configuration surface that should be scoped and audited accordingly.

What to watch next

  • Whether Ada expands the supported Python surface, execution limits or result types.
  • Whether the Tools API gains finer-grained permissions or approval primitives for direct writes.
  • How code-tool execution is metered and whether pricing changes with heavier tool use.
  • Independent evidence on reliability, latency and token savings for production customer-service workflows.

Still unclear

  • Ada’s public release notes and documentation describe runtime behavior and limits but do not provide independent performance or reliability measurements.
  • The current documentation does not establish whether code-tool execution carries a separate usage charge beyond a customer’s existing Ada plan.

Sources

Direct reading behind this dossier.

4 sources
Tools API is available
Ada primary

Official release announcement for code tools, MCP/Platform API authoring and the unified Tools API.

Code tools
Ada primary

Official explanation of tool behavior, use cases, authoring paths and core sandbox constraints.

Tools API
Ada primary

Official CRUD surface, response model and sensitive-field behavior for HTTP and code tools.