Is ATXP competing with the OpenAI Agents SDK?

No. The SDK handles agent logic, memory, and tool-calling orchestration. ATXP handles identity, payments, and tool access. They operate at different layers and work together.

Can I use ATXP tools inside an OpenAI Agents SDK agent?

Yes. ATXP exposes its tools via a standard interface that you can register as tools in the SDK's tool list. Web search, browsing, email, image gen, and others are all callable.

Does the OpenAI Agents SDK handle billing for tool calls?

No. The SDK handles orchestration — deciding when and how to call tools. Billing for the actual tool execution is handled by the provider. With ATXP, all tool calls bill to a single IOU balance.

Do I need an OpenAI account to use ATXP?

No. ATXP is model-agnostic. You can use it with OpenAI, Anthropic, Google, or any other LLM provider. The OpenAI Agents SDK is one integration path, not a requirement.

What the OpenAI Agents SDK Means for ATXP Users

The OpenAI Agents SDK shipped in March 2025 and has become one of the most widely adopted frameworks for building production agents. If you’re using it — or evaluating it — here’s an honest read on what it gives you, what it doesn’t, and how ATXP fits into that picture.

What Is the OpenAI Agents SDK?

The OpenAI Agents SDK is an open-source Python library for building agents with tool use, handoffs, and guardrails. It provides the orchestration layer: an agent loop that decides when to call tools, how to hand off between agents, and how to handle model responses. It’s model-first, built around OpenAI’s APIs, and designed for developers who want structure without having to build the scaffolding from scratch.

It is not a hosted platform. It does not provision accounts, manage payments, or give your agent an identity. It’s a framework — and a good one.

What the SDK Gives You

The SDK covers the parts of agent-building that are genuinely hard to get right from scratch.

Capability	What the SDK Provides
Agent loop	Run → tool call → run again, with proper state management
Tool registration	Decorate functions as tools; SDK handles schema + dispatch
Handoffs	One agent delegates to another with shared context
Guardrails	Input/output validation before and after model calls
Tracing	Built-in trace logging for debugging agent runs
Multi-agent patterns	Orchestrator + sub-agent patterns with typed handoffs

If you’ve tried to build this yourself, you know how much edge-case handling this eliminates. The SDK is worth using on its own merits.

What the SDK Doesn’t Include

The SDK is intentionally scoped to orchestration. It doesn’t try to solve the infrastructure problems that sit beneath or beside it.

Identity. Your agent has no account, no email address, no persistent identity across runs. If you need your agent to receive email, sign into services, or be identified as a specific entity, you’re on your own.

Payments. The SDK can call any tool you register — but it has no built-in mechanism for paying for those calls, managing a budget, or billing a downstream consumer. If your agent calls a paid API, you’re managing that yourself.

Tool access. The SDK doesn’t provision tools. You bring your own: your own search API key, your own browsing setup, your own image generation credentials. Each one requires a separate vendor account, separate billing, and separate key management.

Per-call billing. There’s no concept of IOU tokens, spending limits, or per-task cost attribution inside the SDK. You can build this — many teams do — but it’s not included.

This isn’t a criticism. The SDK made a deliberate scope decision. Orchestration is what it does. The rest is your problem to solve.

How ATXP Fits With the OpenAI Agents SDK

ATXP is the account layer that the SDK assumes you’ve already handled. The two are complementary at the architecture level.

Layer	Handled By
Agent logic and orchestration	OpenAI Agents SDK
Tool registration and dispatch	OpenAI Agents SDK
Agent identity (email, auth, account)	ATXP
Tool access (search, browse, image gen, etc.)	ATXP
Payments and per-call billing	ATXP
Spending limits and budget control	ATXP (IOU tokens)

When you run npx atxp, you get an account with a unique identity, an @atxp.email address, and access to 14+ tools — all billed to a single IOU balance. You register those tools inside the SDK. The SDK decides when to call them. ATXP handles what happens when they fire.

Your agent’s architecture looks like this:

[OpenAI Agents SDK]
  └─ Agent loop + orchestration
  └─ Tool dispatch → [ATXP tools]
                        └─ web search
                        └─ web browsing
                        └─ image generation
                        └─ email (send/receive)
                        └─ code execution
                        └─ file storage
  └─ Identity / payments → [ATXP account]

The SDK doesn’t care where your tools come from. ATXP doesn’t care which orchestration framework you use. They compose cleanly.

Getting Started

If you’re already using the OpenAI Agents SDK, adding ATXP takes a few minutes.

# Provision your ATXP account
npx atxp

# Install the SDK if you haven't already
pip install openai-agents

Once your ATXP account is provisioned, you get a set of tool endpoints and credentials. Register them in the SDK:

from agents import Agent, Tool
import atxp

# ATXP tools register like any other SDK tool
agent = Agent(
    name="research-agent",
    tools=[
        atxp.tools.web_search,
        atxp.tools.browse,
        atxp.tools.send_email,
    ],
    model="gpt-4o"
)

Every tool call bills to your ATXP IOU balance. No separate API keys. No per-tool billing accounts. One dashboard.

For a full how-to walkthrough, see the dedicated integration guide. This post is an explainer — not a tutorial. The point is the framing: you don’t have to choose between the OpenAI Agents SDK and ATXP. Most serious developers using the SDK end up needing exactly what ATXP provides.

The SDK is the engine. ATXP is the infrastructure it runs on.

Want to see how ATXP fits your specific agent architecture? Run npx atxp to provision an account and explore the tool catalog.