ChatGPT Work API Workflow Automation Guide (2026): GPT-5.6 Agents, Tools, and Cost Controls

On July 9, 2026, OpenAI announced ChatGPT Work: an agentic mode in ChatGPT that can use connected apps, browser actions, desktop capabilities, and scheduled tasks to finish multi-step work. The same announcement says it is powered by GPT-5.6, which also became generally available that day.

The product announcement is aimed at end users, but the developer lesson is obvious: workflow automation is moving from “ask a model once” to “give an agent a bounded job, tools, memory, and approval rules.” If you build API products, this is the architecture you should copy. Not blindly, though. Long-running agents are expensive and weirdly good at finding every unsafe edge in your system.

GPT-5.6 API Pricing for Workflow Automation

For agent workflows, output cost matters more than people expect. A planner that makes ten tool calls, writes drafts, revises them, and explains its work can produce a lot of output tokens. Start with explicit routing instead of sending every task to the flagship tier.

Model and Workflow Option Comparison

The Practical Architecture

A ChatGPT Work-style automation has five parts: a goal, a context loader, a planner, a tool executor, and an approval layer. If you skip the approval layer, you don't have an agent. You have a bot with a credit card.

The goal should be short and testable: “create a weekly churn report,” not “help sales.” The context loader pulls the minimum data needed from Slack, Drive, a CRM, or your database. The planner turns that context into steps. The executor calls tools. The approval layer decides what can happen automatically and what must wait for a human.

A Minimal Python Workflow Skeleton

This is not a full OpenAI SDK tutorial. It's the shape you want in production: bounded steps, tool budgets, and a hard stop when the agent tries to do too much.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.openai.com/v1")

TOOLS = [
    {"type": "function", "name": "search_docs", "description": "Search internal docs."},
    {"type": "function", "name": "create_draft", "description": "Create a draft document."}
]

def run_workflow(goal: str, context: str):
    max_steps = 6
    transcript = [{"role": "user", "content": f"Goal: {goal}\n\nContext:\n{context}"}]

    for step in range(max_steps):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=transcript,
            tools=TOOLS,
            instructions="Plan carefully. Ask for approval before external writes."
        )
        transcript.append({"role": "assistant", "content": response.output_text})

        if "NEEDS_APPROVAL" in response.output_text:
            return {"status": "paused", "step": step + 1, "draft": response.output_text}
        if "DONE" in response.output_text:
            return {"status": "done", "result": response.output_text}

    return {"status": "stopped", "reason": "step budget exceeded"}

The important part is not the syntax. It's the budget. Give every workflow a maximum step count, maximum tool calls, maximum output tokens, and maximum wall-clock time.

Node.js: Route by Task, Not by Brand

Most workflow systems waste money by using the same model for everything. A better pattern: use Terra for the main plan, Luna for repetitive transformations, and Sol only when a task is genuinely hard.

const routeModel = (task) => {
  if (task.risk === "high" || task.requiresDeepReasoning) return "gpt-5.6-sol";
  if (task.kind === "extract" || task.kind === "classify") return "gpt-5.6-luna";
  return "gpt-5.6-terra";
};

async function runTask(openai, task, input) {
  return openai.responses.create({
    model: routeModel(task),
    input,
    max_output_tokens: task.maxOutputTokens ?? 1200,
    metadata: { workflow_id: task.workflowId, step: task.name }
  });
}

If you're using an OpenAI-compatible gateway like KissAPI, keep the same routing idea but swap the base URL and key. That gives you a single place to route GPT-5.6 calls, compare alternatives, and keep fallbacks ready when a provider has a bad day.

Approval Rules That Actually Work

Use a simple policy table. Read-only actions can usually run automatically. Draft creation can run automatically if it stays internal. Anything that sends email, posts to Slack, changes billing, modifies production data, or triggers a customer-visible workflow should pause for approval.

Cost Controls Before You Ship

• Log per-step tokens. Store input, cached input, and output tokens by workflow step.
• Set model budgets. A daily Luna budget and a much smaller Sol budget prevents “one weird job” from eating the account.
• Cache stable instructions. Tool descriptions, policy rules, and output schemas should not be rewritten every request.
• Deduplicate scheduled tasks. Scheduled agents should use idempotency keys so a retry doesn't create two reports or two tickets.
• Keep fallback models. If Terra is slow, route low-risk cleanup to Luna or another compatible model instead of failing the whole workflow.

When to Use KissAPI

KissAPI is useful when you want one OpenAI-compatible endpoint for multiple model families, plus a cleaner fallback story. For workflow automation, that matters. A scheduled job should not die just because one model is overloaded for ten minutes.

My preferred setup: route the planner through GPT-5.6 Terra, route extraction through Luna or a cheaper model, keep Sol for escalations, and keep a second provider family as a fallback for non-sensitive steps. That is boring architecture. Boring is good when agents start touching real workflows.

FAQ

What did OpenAI announce about ChatGPT Work on July 9, 2026?

OpenAI announced ChatGPT Work as an agentic mode that can use connected apps, browser actions, desktop capabilities, and scheduled tasks to complete multi-step work.

Is there a separate ChatGPT Work API?

OpenAI's announcement focuses on ChatGPT product capabilities. Developers can still build similar workflow automation using the OpenAI API, tool calls, scheduled jobs, and approval gates.

Which GPT-5.6 model should I use for agents?

Use GPT-5.6 Terra as the default planner, GPT-5.6 Luna for repetitive high-volume steps, and GPT-5.6 Sol for the hardest reasoning or final synthesis steps.