OpenAI introduced Programmatic Tool Calling (PTC) with the GPT-5.6 family on July 9, 2026. A conventional tool loop alternates between model judgment and application execution. PTC instead lets the model generate JavaScript that calls eligible tools in parallel, loops over results, applies conditions, and emits a reduced structured result from a hosted runtime. Its request skeleton does not make a paid API call.

Decide whether the stage fits PTC

PTC fits a bounded stage with predictable control flow and many results that code can filter, join, rank, deduplicate, aggregate, or validate. One example is querying build status for several repositories and grouping failures by test. It is a poor fit for adaptive research where every result changes the next semantic decision. A single lookup is clearer as a direct call. Payments, deletion, publication, and other approval-sensitive writes should also remain direct so the application can authorize the exact action after its arguments are known.

The presence of multiple calls is not enough. The useful gain comes from reducing intermediate context and model round trips: a program transforms large tool outputs into a small object with retained evidence, and the model explains that object.

Configure a read-only programmatic stage

Add the programmatic_tool_calling hosted tool and opt eligible tools in through allowed_callers. If a function has predictable structured output, declare output_schema; generated JavaScript otherwise cannot rely safely on returned fields.

const tools = [
  {
    type: "function",
    name: "get_build_status",
    description: "Return repo, branch, status and failed_tests.",
    parameters: {
      type: "object",
      properties: { repo: { type: "string" } },
      required: ["repo"],
      additionalProperties: false
    },
    output_schema: {
      type: "object",
      properties: {
        repo: { type: "string" },
        status: { type: "string" },
        failed_tests: { type: "array", items: { type: "string" } }
      },
      required: ["repo", "status", "failed_tests"],
      additionalProperties: false
    },
    allowed_callers: ["programmatic"],
    strict: true
  },
  { type: "programmatic_tool_calling" }
];

const response = await client.responses.create({
  model: "gpt-5.6-terra",
  input: orchestrationPrompt,
  tools,
  store: false
});

The server must still validate arguments, tenant identity, and resource scope before executing the function. allowed_callers configures an invocation route; it is not an authorization system. The generated program may be isolated while the tools it can call still reach real systems.

Put an orchestration contract in the prompt

“Use PTC efficiently” is not a routing policy. Name the bounded stage, eligible tools, required result shape, concurrency, retry and stopping limits, and the handoff to direct calls.

Use PTC only for the build-status aggregation stage and only call get_build_status.
Query the supplied repositories concurrently, at most once per repository.
Retry a transient failure once. Return {total, passed, failed, evidence[]}.
Evidence must preserve repository and failed test names. Never perform a write.
Return a structured failure when a required field is missing; do not guess.
Use a direct tool call with approval for any rebuild or release action.

This contract makes failures observable and prevents the model from switching repeatedly between programmatic and direct routes or repeating completed work.

Pin the model and the cost snapshot

The gpt-5.6 alias routes to Sol. OpenAI positions Sol for frontier capability, Terra for a balance of intelligence and cost, and Luna for efficient high-volume work. PTC availability is not a reason to default every workload to the largest tier. Run the same orchestration eval on the candidate tiers and choose the smallest one that preserves correctness and evidence. Sol’s standard text price is $4 per million input tokens and $20 per million output tokens after the August 21 adjustment. Pricing is not a permanent constant: store the actual model, billing data, evaluation date, uncached and cached tokens, tool charges, retries, and end-to-end latency with every benchmark. PTC can reduce intermediate model turns, but the hosted and client-owned tools may still have independent cost and rate limits.

Preserve the continuation relationship

PTC still returns a standard Responses API object. Its output may contain a program item, client-owned function_call items issued by that program, and a program_output. After running a client-owned function, the application must return the result with the original call_id and caller relationship. With store: false, continuation requires replaying response items; a stored response can continue through previous_response_id. Treat an incomplete status, timeout, missing field, or exhausted retry budget as a controlled failure rather than silently accepting partial data.

Each generated program runs in a fresh isolated V8 runtime with top-level await. It has no Node.js, package installation, direct network access, general filesystem, subprocesses, console, or persistent JavaScript state. External access is possible only through enabled tools. That isolation narrows the attack surface but does not replace tool permissions, server validation, quotas, or audit logs.

Validate two distinct outputs

A correct program_output does not guarantee a complete final assistant message. The final answer may omit a required field, evidence item, citation, or caveat. Compare direct and programmatic calling on the same representative cases. Check correctness and evidence first; then measure tokens, latency, calls, turns, and retries. Lower resource use is an improvement only when the existing evals still pass.

Start with one read-only, replayable aggregation stage whose raw outputs are large. Give each tool strict input and output contracts, bound calls and retries, and leave every consequential write behind a direct approval boundary. PTC is valuable not because it grants an agent more authority, but because it moves deterministic orchestration out of repeated model turns while preserving a reviewable evidence path.