AgentField vs OpenAI Agents SDK and open-source frameworks
OpenAI Agents SDK is a light framework for agents, handoffs and tracing. AgentField is an open-source backend for any model. How they compare and combine.
The OpenAI Agents SDK is itself open source (MIT), so the real choice is not open versus closed: it is a lightweight agent loop that is best on OpenAI models, against open-source frameworks such as LangGraph, CrewAI and Pydantic AI that put model portability first, and AgentField, an open-source (Apache 2.0) control plane that runs agents from any of them as backend services on any model. Pick by where your problem is: authoring an agent, keeping it portable, or running it in production.
At a glance
Competitor facts checked on 2026-11-21 against each project's repo and docs.
| AgentField | OpenAI Agents SDK | Pydantic AI | LangGraph | CrewAI | |
|---|---|---|---|---|---|
| Layer | Control plane: agents as HTTP services | Agent framework | Agent framework | Graph framework and runtime | Multi-agent framework |
| Licence | Apache 2.0 | MIT (Python, JS) | MIT (repo) | MIT (repo) | MIT (repo) |
| Languages | Python, TypeScript, Go | Python, TypeScript | Python | Python, JavaScript/TypeScript | Python |
| Models | 100+ through LiteLLM (Python), Vercel AI SDK (TypeScript), OpenAI-compatible HTTP (Go) (docs) | OpenAI first; others via OpenAI-compatible clients, LiteLLM (beta) or Any-LLM (beta) (docs) | "Virtually every model and provider", including Ollama (docs) | Not covered on this page; see LangChain's provider integrations | Native SDKs plus LiteLLM providers and Ollama (docs) |
| Human-in-the-loop | app.pause(), crash-safe, 72-hour default expiry | Built-in human-in-the-loop (docs) | Tool approval built in | Interrupts | Human input (README) |
| Tracing | Workflow DAG on your control plane; OpenTelemetry-compatible headers | On by default, sent to OpenAI; replaceable processors (docs) | OpenTelemetry; "any OTLP backend works" | LangSmith | AMP tracing |
| Runs as a service | Every reasoner is an endpoint; async, queue, webhooks | Library in your process | Library; durable on engines such as Temporal or DBOS | Library; LangSmith Deployment | Library; CrewAI AMP |
| Governance and identity | Policy before execution, W3C DIDs, signed receipts | Guardrails on inputs and outputs | Not documented on the overview | Not in the library | Enterprise plan (SSO, RBAC) |
What the OpenAI Agents SDK does well
The SDK keeps the API small: agents ("LLMs equipped with instructions and tools"), agents as tools and handoffs, guardrails that validate inputs and outputs, sessions for working memory, human-in-the-loop, MCP tool calling, sandbox agents, realtime and voice agents, and built-in tracing (docs). Tracing connects to OpenAI's evaluation, fine-tuning and distillation tools. If you are on OpenAI models and want the shortest path from idea to working agent with handoffs, it is hard to beat, and Temporal lists an official integration for it in Python and TypeScript (Temporal AI docs).
Model portability: the fair difference
The SDK supports non-OpenAI models through an OpenAI-compatible client, a custom ModelProvider, or the LiteLLM and Any-LLM adapters, both marked beta. Its own docs add caveats: hosted file search and web search are not supported by "many other providers", Responses-only features are rejected on Chat Completions models, and "feature support and request semantics can vary by provider" (models docs). Traces upload to OpenAI by default, so without an OpenAI key you disable tracing or install another processor, and tracing "is unavailable for organizations that use OpenAI's APIs under a Zero Data Retention (ZDR) policy" (tracing docs).
AgentField treats the model as a per-call parameter. From the models docs:
app = Agent(
node_id="resilient-agent",
ai_config=AIConfig(
model="anthropic/claude-sonnet-4-20250514",
fallback_models=[
"openai/gpt-4o",
"openrouter/google/gemini-2.5-pro",
"deepseek/deepseek-chat",
],
timeout=30,
retry_attempts=3,
),
)A local model is model="ollama/llama3" with api_base="http://localhost:11434". Traces stay on your own control plane. The guide to running agents without lock-in goes further.
The service boundary and governance
An SDK agent runs inside the process that imports it. AgentField puts a boundary around agents: app.run() exposes each reasoner at POST /api/v1/execute/<node>.<reasoner>, long work goes through POST /api/v1/execute/async/{target} and returns 202 with an execution ID, and agents call each other with app.call() through the control plane (how it works). Guardrails in the SDK check what a model says; AgentField's tag-based policy checks who may call which function before it runs, and with enable_did=True each agent gets an Ed25519-backed DID (identity).
Using the SDK with AgentField
The two combine. An SDK agent can run inside an AgentField reasoner, which gives it an endpoint, async execution, approvals and audit; our docs say any framework's model call "can sit behind an AgentField reasoner or skill", while recommending native primitives where you can (FAQ). The reasoner below is an example, not tested:
# Example, not tested: an OpenAI Agents SDK agent behind an AgentField reasoner.
from agents import Agent as SDKAgent, Runner
from agentfield import Agent
app = Agent(node_id="support")
triage = SDKAgent(name="Triage", instructions="Classify the ticket and draft a reply.")
@app.reasoner()
async def handle_ticket(text: str) -> dict:
result = await Runner.run(triage, text)
return {"reply": result.final_output}
app.run()When to choose the OpenAI Agents SDK
Choose it when you build on OpenAI models and want handoffs, guardrails, sessions, realtime voice and tracing that plugs into OpenAI's evaluation tools, with minimal code. Choose Pydantic AI for typed Python agents across providers with durable execution on an engine you already run. Choose LangGraph for explicit graphs and checkpoints (comparison) and CrewAI for role-based teams (comparison). Each has a larger community than AgentField today.
When to choose AgentField
Choose AgentField when agents must be callable by other services, run for minutes or hours, switch models per call, and carry identity, policy and an audit trail, in Python, TypeScript or Go, on infrastructure you control.
Questions people ask
Is the OpenAI Agents SDK open source?
Yes. Both the Python and the JavaScript/TypeScript versions are MIT-licensed on GitHub (checked 2026-11-21). The difference from other open-source frameworks is that it is designed around OpenAI's APIs, with other providers supported through adapters.
Can the OpenAI Agents SDK use non-OpenAI models?
Yes, through an OpenAI-compatible client, a custom model provider, or the LiteLLM and Any-LLM adapters, which are in beta. OpenAI's docs warn that hosted tools and Responses-only features may not work with other providers, so validate the backend you deploy.
Where do OpenAI Agents SDK traces go?
By default, to OpenAI's Traces dashboard. You can disable tracing with OPENAI_AGENTS_DISABLE_TRACING=1 or replace the processors with your own. Tracing is unavailable for organisations under OpenAI's Zero Data Retention policy.
Which agent framework is most portable across models?
Pydantic AI lists virtually every model and provider, CrewAI reaches many providers through native SDKs and LiteLLM, and AgentField supports 100+ models through LiteLLM in Python, with per-call model choice and fallback chains. AgentField also keeps traces and execution records on your own control plane.
Does AgentField replace the OpenAI Agents SDK?
Not necessarily. AgentField has its own model calls, tools and structured output, so it can replace it, but an SDK agent can also run inside an AgentField reasoner. AgentField then adds the endpoint, async execution, policy, identity and audit around it.
Sources
- OpenAI Agents SDK docs, models and tracing: https://openai.github.io/openai-agents-python/, https://openai.github.io/openai-agents-python/models/, https://openai.github.io/openai-agents-python/tracing/ (checked 2026-11-21)
- OpenAI Agents SDK repos: https://github.com/openai/openai-agents-python, https://github.com/openai/openai-agents-js (checked 2026-11-21)
- Pydantic AI: https://pydantic.dev/docs/ai/overview/, https://github.com/pydantic/pydantic-ai (checked 2026-11-21)
- LangGraph repo: https://github.com/langchain-ai/langgraph (checked 2026-11-21)
- CrewAI repo and LLM docs: https://github.com/crewAIInc/crewAI, https://docs.crewai.com/en/concepts/llms (checked 2026-11-21)
- Temporal AI integrations: https://docs.temporal.io/ai (checked 2026-11-21)
Last updated 2026-11-21. Licences read from the GitHub API that day; OpenAI Agents SDK features read from its documentation that day.