Sim vs OpenAI AgentKit
Sim is the open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. Here is how Sim compares to OpenAI AgentKit on platform architecture, AI capabilities, integrations, pricing, security, and support. Every fact below is sourced and dated.
Sim is an open-source AI workspace for building, deploying, and managing AI agents. This page compares Sim to OpenAI AgentKit across platform architecture, AI capabilities, integrations, pricing, security and compliance, observability, and support, using sourced, dated facts for buyers evaluating both platforms.
What is Sim?
Sim is the open-source AI workspace where teams build, deploy, and manage AI agents, connecting 1,000+ integrations and every major LLM to automate real work visually, conversationally, or with code.
What is OpenAI AgentKit?
OpenAI AgentKit bundled a visual Agent Builder, ChatKit embeddable chat UI, Connector Registry, Guardrails, and Evals for building agentic workflows on OpenAI's models. But OpenAI is winding down Agent Builder and Evals, with full shutdown November 30, 2026, in favor of the code-first Agents SDK or ChatGPT Workspace Agents.
Sim vs OpenAI AgentKit: feature-by-feature comparison
CompareSim vs OpenAI AgentKit
Sim
OpenAI AgentKit
Platform
Builder type
Sim
Visual canvas, chat, or codeVisual drag-and-drop canvas, natural-language (Chat), or code (API/SDK)
OpenAI AgentKit
Visual canvas, deprecated in favor of code-first SDKVisual canvas (Agent Builder) for drag-and-drop multi-agent workflow construction, paired with a code-first alternative (Agents SDK, Python/TypeScript). Agent Builder was a visual, node-based canvas for creating and versioning multi-agent workflows with typed inputs/outputs and live-data preview. It is being deprecated (shutdown November 30, 2026) in favor of the code-first Agents SDK, making the long-term builder paradigm code-based rather than visual.
Learning curve
Sim
Low, plus natural-language Chat for non-technical usersLow for visual building; natural-language Chat surface for non-technical builders. Chat lets users describe a workflow in plain language and have Sim build it.
OpenAI AgentKit
Not publicly documentedUnknown. Agent Builder targeted low-code use and the Agents SDK targets Python/TypeScript developers, but no source quantifies the learning curve for either.
Self-hosting
OpenAI AgentKit
Not self-hostable; only ChatKit frontend can beNot self-hostable as a platform; only the ChatKit frontend/SDK can run on your own infrastructure against a custom backend. Agent Builder, Evals, and Connector Registry are OpenAI-hosted SaaS features with no self-host option. ChatKit's advanced integration path lets you run the ChatKit Python SDK on your own infrastructure, but the agent workflow logic is code you write and host yourself, not a self-hosted version of Agent Builder.
Deployment options
Sim
Cloud-hosted or self-hosted, no mid-tier VPC optionCloud-hosted (managed, multi-tenant SaaS) or self-hosted (Docker/Kubernetes). No documented managed single-tenant/VPC hosting tier in between. The Enterprise plan's only hosting-related row in the pricing comparison table is a boolean "Self Hosting" flag; there is no dedicated-instance/VPC offering.
OpenAI AgentKit
OpenAI-hosted only; Agents SDK deploys anywhereOpenAI-hosted cloud only for Agent Builder/Evals (being shut down); Agents SDK code can be deployed anywhere that runs Python/TypeScript (e.g., AWS Lambda, Cloudflare Workers, FastAPI servers). There is no official Docker/Kubernetes distribution of AgentKit itself; deployment flexibility comes from the open-source Agents SDK being ordinary application code.
Templates
Sim
License
Sim
Apache 2.0Apache License 2.0
OpenAI AgentKit
Proprietary platform; Agents SDK is MITProprietary (Agent Builder/ChatKit/Evals platform); the Agents SDK (openai-agents-python) is open source under MIT license. AgentKit as a hosted product suite is proprietary SaaS. The companion Agents SDK repository is MIT-licensed and open source on GitHub.
Environment promotion
Sim
Yes: fork a whole workspace into a dev/qa/prod-style child, diff it, and promote or roll back changes in either direction. Credential and env-var remapping is required before every promote, so secrets are never silently copied across environments. Gated to Enterprise plan on hosted Sim, or a FORKING_ENABLED flag on self-hosted deployments.
OpenAI AgentKit
No dev/qa/prod-style environment promotion for full projects. Only single-workflow versioning and code export. Agent Builder workflows export as code (Agents SDK, Python or TypeScript) or JSON templates, and templates can sync with a Git repo for reuse, but there's no built-in feature to clone a whole project and promote it between dev/qa/prod environments. Promoting environments means exporting to code and managing them yourself, which lines up with third-party reviews noting Agent Builder lacks production-grade deployment pipelines. Agent Builder is being deprecated, with full shutdown November 30, 2026, in favor of the code-first Agents SDK or ChatGPT Workspace Agents.
Version control
Sim
Deployment rollback plus Copilot edit diff/revertDeployed-version history with rollback for every workflow; server-persisted checkpoint/revert and visual diff (accept/reject) specifically for Copilot AI edits. Manual drag-and-drop undo/redo is client-side/localStorage only (capped at 100 ops, 5 stacks), not server-synced across devices. Deployment history does not include an arbitrary version-to-version diff tool, and knowledge base documents have no version history.
OpenAI AgentKit
Version snapshots, no rollback or diff viewPublish creates a major version snapshot; API can target older versions; autosave + manual checkpoints, but no documented rollback UI, diff/compare view, or branching. Publishing a workflow in Agent Builder creates a new major version acting as a snapshot, and API calls can target an older version. The workspace autosaves continuously and supports manual version checkpoints, but there is no rollback button, visual diff/compare-versions view, or branching. Third-party reviews note Agent Builder still lacks production-grade features like rollback, observability, and deployment pipelines.
Realtime collaboration
Sim
OpenAI AgentKit
No: OpenAI does not document live, multi-user editing of the same Agent Builder canvas with shared cursors or selections. Teams instead collaborate asynchronously, by importing/exporting workflow JSON, syncing with a Git repo, and publishing versioned snapshots.. Some third-party blog posts describe Agent Builder as supporting 'collaborative editing,' but this isn't confirmed in official OpenAI docs and likely refers to the async JSON/Git sharing model.
Native file storage
Sim
Yes: a native Files area with folder hierarchy, link-based sharing (public, password, email OTP, or SSO auth), and a workspace-level Recently Deleted view covering workflows, tables, knowledge bases, files, and folders. Admins can restrict which share-auth modes (public/password/email/SSO) a permission group is allowed to use.
OpenAI AgentKit
No: Agent Builder/AgentKit has no file storage system of its own (no folders, link sharing, or deleted-item recovery). Files are instead handled through the Connector Registry, which points to external storage providers (Dropbox, Google Drive, SharePoint, Microsoft Teams), or through per-call uploads to file search/code interpreter.
Sub-workflows (composition)
Sim
OpenAI AgentKit
No: Agent Builder's node reference (Start, Agent, Note, File search, Guardrails, MCP, If/else, While, Human approval, Transform, Set state) has no node that calls a separate saved workflow as a nested step and waits for it to finish. Composition across agents happens via handoffs between Agent nodes within the same workflow canvas, not by invoking another independently saved workflow as a reusable child step.. A workflow can call other agents through handoffs (execution transfers to another Agent node, carrying conversation state), but that is agent-to-agent handoff inside one workflow graph, not a call-another-workflow-and-return block. The only way to reuse a workflow elsewhere is to export it as Agents SDK code and call that code from other code, a code-level reuse pattern rather than a visual sub-workflow step.
Pricing
Pricing model
Sim
Credit-based billing, BYOK exempt from capsCredit-based usage billing (Stripe), with bring-your-own-key exemption from metered caps
OpenAI AgentKit
Usage-based tokens plus tool feesUsage-based (per-token model pricing plus per-call/per-session tool pricing). No flat AgentKit subscription. Agent Builder was free to design in. Costs are incurred only when workflows run, through standard OpenAI API token pricing (e.g., gpt-5.5: $5.00/M input, $30.00/M output tokens) plus tool-specific charges: Code Interpreter runs $0.03-$1.92 per session by memory tier (billed per minute, five-minute minimum), and File Search costs $0.10/GB-day for storage (1 GB free) plus $2.50 per 1,000 tool calls. Agent Builder itself is being deprecated, with full shutdown November 30, 2026, so this pricing model applies only until then.
Entry paid plan
Sim
Pro plan at $25/user/monthPro: $25 per user/month
Free tier
Sim
OpenAI AgentKit
Yes, partially: Agent Builder was free to design in, and ChatKit/File Search each include an initial 1 GB of free storage before per-GB-day charges apply. Agent Builder let you design and iterate at zero cost until you ran a workflow. ChatKit includes 1 GB of free file/image storage per account per month before $0.10/GB-day applies, and File Search includes a one-time free GB of storage before the same rate applies, a standing allowance rather than a recurring daily reset.
Bring your own key
Sim
OpenAI AgentKit
No; OpenAI models onlyNot applicable / no. AgentKit runs exclusively on OpenAI's own billed models; there is no BYOK mechanism to swap in a different LLM provider's API key. Since all model calls route through OpenAI's own metered API, there's no bring-your-own-key concept for third-party LLM providers within Agent Builder or the Agents SDK the way a multi-LLM platform would offer it.
Security & compliance
SOC 2
OpenAI AgentKit
Yes: SOC 2 Type 2, plus ISO 27001, 27017, 27018, and 27701 certifications. OpenAI's most recent SOC 2 report covers January 1, 2025 through June 30, 2025 for Security, Availability, Confidentiality, and Privacy Trust Services Criteria across the API Platform, ChatGPT Enterprise, ChatGPT Edu, and ChatGPT Team.
Data residency
Sim
Full control via self-hosting; Cloud region toggle is global, not per-customerFull data control via self-hosting (Docker/Kubernetes); data never leaves customer infrastructure when self-hosted. On Sim Cloud, async job execution has an internal US/EU region toggle, but it is deployment-wide, not a customer-selectable per-workspace residency option
OpenAI AgentKit
Yes: data residency at rest available in US, Europe, UK, Japan, Canada, South Korea, Singapore, Australia, India, and UAE for eligible enterprise customers. Eligible ChatGPT Enterprise, ChatGPT Edu, ChatGPT for Healthcare, and API platform customers can store content at rest in these regions; eligible customers can also opt into in-region GPU inference in the U.S. or Europe.
Role-based access control
OpenAI AgentKit
Yes, at the organization level. The Global Admin Console gates access to the Connector Registry, and the Admin API lets Organization Owners assign custom roles and enable or disable specific apps and actions. Granular access scoped to individual Agent Builder workflows is not documented.. The Global Admin Console manages access to the Connector Registry used by Agent Builder, and the Admin API lets Organization Owners centrally manage workspaces, assign custom roles to teams, and enable/disable specific apps and actions. This is org/admin-level RBAC, not workflow-scoped permissions within Agent Builder itself.
Audit logging
Sim
OpenAI AgentKit
Yes, at the platform level. An Admin/Audit Logs API covers the API Platform (API key creation, role changes, login attempts, project changes), and a separate Compliance Logs Platform covers ChatGPT Enterprise/Edu workspaces (conversations, file uploads, admin actions, auth events, agent activity). No source ties audit logging specifically to individual Agent Builder workflow runs.. OpenAI provides an Admin/Audit Logs API for the API Platform and a Compliance Logs Platform for ChatGPT Enterprise/Edu workspaces, covering admin actions, authentication events, and agent activity broadly, but no documentation confirms audit logging scoped specifically to Agent Builder workflow executions.
Additional compliance
Sim
SOC2SOC2. Self-hosting is the primary lever Sim offers for data-residency-sensitive compliance needs beyond SOC2, rather than additional certifications.
OpenAI AgentKit
SOC 2, ISO 27001/27701, HIPAA/GDPR supportSOC 2 Type 2, ISO/IEC 27001:2022, ISO/IEC 27701:2019; supports customer HIPAA/GDPR/CCPA/FERPA compliance via DPA + BAA. OpenAI's SOC 2 Type 2 examination (Security, Availability, Confidentiality, Privacy criteria) covers the API Platform, ChatGPT Enterprise, ChatGPT Edu, and ChatGPT Team, alongside ISO/IEC 27001:2022 and ISO/IEC 27701:2019 certifications for the same services. OpenAI supports customers' compliance with GDPR, CCPA, HIPAA, and FERPA, and offers a Data Processing Addendum and a Business Associate Agreement for HIPAA-regulated customers. This is enablement rather than OpenAI itself being HIPAA-certified, since HIPAA has no formal certification body. No FedRAMP or PCI attestation was found for the AgentKit/API products.
Model & tool governance
Sim
Yes: enterprise "permission groups" let an admin allow-list/deny-list specific LLM providers and models, and separately deny specific tools/integrations (or disable all MCP or custom tools) per group, layered on top of workspace admin/write/read roles. This does not control whether an LLM provider retains prompts. Sim offers no "zero data retention" mode or governed AI gateway. A separate, Enterprise-gated feature lets orgs set a log-retention window and redact PII, but that only controls how long Sim itself keeps execution logs.
OpenAI AgentKit
Not publicly documentedUnknown. Not publicly documented in available vendor sources.
Credential governance
Sim
Yes: shared credentials (connected accounts, service accounts, workspace secrets) are their own nested permission level (Member/Admin) below organization and workspace roles, and enterprise permission groups can further allow-list specific integrations and restrict which file-share auth modes (public/password/email/SSO) a group may use. A user's personal environment variables/secrets are never shared or inherited by anyone, including org owners/admins.
OpenAI AgentKit
Yes: ChatGPT Enterprise/Business workspaces support role-based access control (RBAC) that restricts which connectors/apps (and by extension their underlying stored credentials) a given custom role or permission group may use, per-app and per-role, with all apps disabled by default until an admin enables them for specific roles.. Granularity is at the connector/app level (e.g. this role may use Google Drive, that role may not) rather than restricting individual named credential instances within a connector type.
Single sign-on (SSO)
Sim
OpenAI AgentKit
Yes: OpenAI supports SAML-based SSO for ChatGPT Enterprise/Edu/Business and the API Platform, with organization auto-provisioning available either via Automatic Account Creation (email-domain matched invitations) or SCIM-based Directory Sync that invites users based on Identity Provider group membership.. Requires prior verification of at least one domain to enable SSO.
Vetted first-party integrations
Sim
Yes: every one of Sim's 302 blocks is first-party authored and code-reviewed through the standard pull-request process in the main Sim repository; there is no public marketplace where an arbitrary third party can publish and have other users install executable tool code without going through Sim's own review. Custom code steps run inside Sim's own isolated-vm sandbox rather than as an installable third-party skill package, so the supply-chain trust boundary is Sim's codebase review, not an open registry.
OpenAI AgentKit
Partial: reviewed first-party catalog, but open MCP server connectionsPartial: pre-built Connector Registry entries (Dropbox, Google Drive, SharePoint, Teams) and the ChatGPT Apps directory go through OpenAI identity verification and app review, but Agent Builder's MCP node and the Agents SDK can connect to any third-party MCP server with no vendor vetting pipeline documented. OpenAI's own Connector Registry connectors and ChatGPT Apps directory submissions require developer identity verification and pass through an OpenAI app-review process before listing, per the App submission guidelines. But Agent Builder's MCP node and the Agents SDK let a builder point at any hosted MCP server, first-party or community-run, with no OpenAI review of that server's code. This client-only MCP model mirrors the wider MCP ecosystem, where unreviewed community servers have shipped malicious behavior elsewhere (for example, an unofficial third-party Postmark MCP server was found in September 2025 silently BCC'ing all outgoing email to an attacker). No security incident specific to OpenAI's own Connector Registry, Apps directory, or Agent Builder MCP integration has been publicly reported.
PII redaction
Sim
OpenAI AgentKit
Yes: Agent Builder's Guardrails node includes a built-in PII detection and redaction capability that automatically catches and masks sensitive data (names, phone numbers, account IDs) flowing through a workflow, alongside jailbreak-detection and content-moderation checks, distinct from generic output-validation guardrails.
Custom data retention
Sim
OpenAI AgentKit
No: OpenAI's Compliance Logs Platform retains data for a fixed 30 days (not org-configurable), and API Platform audit logs have no fixed retention/TTL at all rather than an admin-adjustable window; there is no documented org-configurable retention setting for Agent Builder workflow execution logs specifically.. Customers wanting longer retention must build their own continuous log-download pipeline rather than set a retention window in the product.
White-labeling
Sim
OpenAI AgentKit
No: ChatKit (the deployment surface for Agent Builder workflows) only supports surface-level theming, colors, typography, density, and rounded corners, not full white-labeling. Deeper brand replacement, such as changing the chat bubble shape, header layout, or removing OpenAI product identity, requires forking the ChatKit library.. A third-party technical review explicitly notes deep white-label branding is 'impossible without forking the entire ChatKit library.'
AI capabilities
Multi-LLM support
Sim
21 providers incl. OpenAI, Anthropic, Google, Bedrock21 provider integrations (OpenAI, Anthropic, Google/Gemini, Azure OpenAI, Azure Anthropic, Groq, Cerebras, Mistral, xAI, Bedrock, Vertex, Ollama, OpenRouter, and more). apps/sim/providers/models.ts defines 21 provider entries; openrouter/litellm/vllm/ollama resolve models dynamically at runtime rather than from a hardcoded model list.
OpenAI AgentKit
OpenAI models onlyOpenAI models only (GPT-5 family, e.g. gpt-5.5, gpt-5.4, gpt-5.4-mini). AgentKit and the Agents SDK are built around OpenAI's own model lineup; no vendor documentation offers native first-party support for non-OpenAI LLM providers (e.g., Anthropic, Google) inside Agent Builder or ChatKit.
Agent reasoning blocks
Sim
Natural-language building
OpenAI AgentKit
Not publicly documentedUnknown. No primary OpenAI source describes a chat-to-build / natural-language-to-workflow generation feature within Agent Builder itself, distinct from agents' own natural-language capabilities at runtime.
Knowledge base / RAG
Sim
MCP support
Sim
Evaluation & guardrails
Sim
LLM-judge Evaluator plus Guardrails validation blockEvaluator block (LLM-judge scoring against user-defined named metrics) and Guardrails block (JSON validity, regex, RAG/hallucination scoring, PII detection/masking). These are per-call scoring/validation primitives, not a batch golden-dataset eval-suite runner or A/B prompt-testing harness.
OpenAI AgentKit
Yes: Evals (datasets, trace grading, automated prompt optimization) and a separate open-source Guardrails layer, but Evals is being deprecated alongside Agent Builder. AgentKit shipped Datasets, Trace grading, and Automated prompt optimization under Evals, plus an open-source modular Guardrails safety layer (PII masking, jailbreak detection). Evals goes read-only October 31, 2026 and is fully shut down November 30, 2026, alongside Agent Builder.
Human-in-the-loop
Sim
OpenAI AgentKit
Yes: dedicated 'Human approval' node in Agent Builder; SDK-level tool-approval interrupts in Agents SDK. Agent Builder has a first-class Human approval logic node that lets a workflow pause for a person to approve or reject a step before continuing (e.g., approve/reject an agent-drafted email before an MCP node sends it). At the SDK level, tool calls flagged as needing approval pause the run and surface as a pending interruption, then resume from saved state once the developer approves or rejects it. There's no built-in approver-notification channel (no native email/Slack alert); the surrounding app has to present the pending approval itself, though the resume mechanism is native.
Generative media
Sim
OpenAI AgentKit
Image generation only, via tool callImage generation only, via tool call; no built-in video or audio (TTS/STT) generation node. Agent Builder's node palette (Start, Agent, Note, File search, Guardrails, MCP, If/else, While, Human approval, Transform, Set state) has no dedicated image/video/audio node. Agents can invoke OpenAI's separate image generation tool (GPT Image models) as a tool call. Audio (Whisper transcription/TTS) and video (Sora) are separate OpenAI API products, not surfaced as canvas nodes. No third-party media-gen providers are wired in as nodes.
Dynamic tool use
Sim
No: an Agent block calls tools the workflow author explicitly added to it at build time, rather than browsing and picking from a broader pool (e.g. an entire MCP server catalog) at inference time. Runtime MCP "discovery" exists to resolve/refresh the schema of an already-configured tool. The model does not browse or choose from the server's full tool list.
OpenAI AgentKit
Not publicly documentedUnknown. Not publicly documented in available vendor sources.
Automatic model fallback
Sim
No: a failed or rate-limited LLM call is retried using Sim's own hosted API keys for the same model, rather than automatically switching to a different model or provider. A "fallback" comment in the provider layer refers to rotating among Sim's own hosted API keys for the same model, not switching models.
OpenAI AgentKit
Not publicly documentedUnknown. Not publicly documented in available vendor sources.
Agent skills
Sim
Yes: named, reusable "Agent Skills" (built on the open Agent Skills / SKILL.md format) that agents load on demand via progressive disclosure, editable in-app or imported from a SKILL.md file or GitHub URL. Only the skill name and description sit in the agent's system prompt (~50-100 tokens each); the full instructions load into context only when the agent calls load_skill.
OpenAI AgentKit
No: Agent Builder/AgentKit has no dedicated feature for defining a reusable, named prompt or knowledge snippet that multiple agents can share by reference. OpenAI's separate reusable-prompts feature is itself being phased out and is scheduled to shut down November 30, 2026, alongside Agent Builder. A distinct 'Agent Skills' concept exists only in the unrelated Codex product line, not in AgentKit.. OpenAI recommends migrating reusable prompts to code-managed, versioned helper files instead, which is the opposite direction of a built-in skills feature.
Native chat deployment
Sim
OpenAI AgentKit
Yes: ChatKit is a native toolkit for embedding a publicly deployable, customizable chat-based agent surface (web widget) backed by a published Agent Builder workflow ID or the Agents SDK, distinct from just a form/API/webhook target.. ChatKit remains available even as Agent Builder itself is being wound down (shutdown November 30, 2026).
Parallel execution
Sim
Yes: a native Parallel block fans a run out into concurrent branches (fixed count or one per list item) and joins their results back into the workflow automatically. Contained blocks run concurrently instead of sequentially, either a fixed number of times or once per item in a list/collection, and each branch's output aggregates for downstream blocks.
OpenAI AgentKit
No dedicated node in the visual Agent Builder canvas. Its node palette (Start, Agent, Note, File search, Guardrails, MCP, If/else, While, Human approval, Transform, Set state) has no fan-out/fan-in or 'parallel branches' node; If/else and While are the only branching/looping constructs, and both execute sequentially. Concurrent multi-agent execution requires writing code against the separate Agents SDK (e.g. Python asyncio to run agents in parallel and merge results), not the no-code builder.. OpenAI developer community threads on Agent Builder confirm the canvas lacks a fan-out block and point developers to the Agents SDK for true concurrent branch execution.
Agent2Agent (A2A) protocol
Sim
OpenAI AgentKit
No: not documented as supported by AgentKit or the Agents SDK. No OpenAI documentation, changelog, or product page for AgentKit, Agent Builder, or the Agents SDK describes support for the Agent2Agent (A2A) protocol or Agent Cards. A2A is an open standard originated by Google and now under the Linux Foundation; OpenAI's own interoperability story is built around MCP (tool-calling) rather than A2A peer-to-peer agent discovery.
Loop / iteration block
Sim
OpenAI AgentKit
Yes: Agent Builder has a dedicated 'While' logic node that loops on a custom Common Expression Language (CEL) condition, re-running the connected steps sequentially each pass until the condition is false.. The While node is condition-based rather than an explicit for-each-over-a-list container: iterating over a list means writing a CEL expression that checks an index or remaining-items condition against a Set-state variable, and incrementing that variable each pass, rather than dropping in a purpose-built for-each block. Iterations run one after another (sequential), matching the node palette's lack of any fan-out/parallel node.
Integrations
Integrations
Sim
302 blocks, ~3,900 tool actions302 first-party blocks, ~3,900 underlying tool actions. Sim's landing page cites "1,000+ integrations," a broader figure counting individual API actions rather than top-level blocks. Both numbers describe the same integration surface.
OpenAI AgentKit
No published total connector countUnknown exact count. OpenAI names specific pre-built connectors (Dropbox, Google Drive, SharePoint, Microsoft Teams) plus support for arbitrary third-party MCP servers, but publishes no total integration/connector count comparable to a competitor's marketed number.
Trigger types
Sim
Webhook, cron, chat, REST API, triggers for 61 appsWebhook, schedule/cron, chat, REST API, and event-based triggers for 61 apps (Slack, Gmail, GitHub, Stripe, etc.)
OpenAI AgentKit
Not comprehensively documentedUnknown / not comprehensively documented. Primary sources describe workflow execution via API calls and ChatKit chat interfaces; no vendor page enumerates trigger types (webhook, schedule, app-event) the way a workflow-automation product typically does.
Custom code steps
OpenAI AgentKit
Yes, effectively. The Agents SDK is itself Python/TypeScript code, and Agent Builder workflows can call custom tools/functions. Because the long-term supported path is the code-first Agents SDK (Python and TypeScript), custom code isn't a step type bolted onto a no-code canvas. It's the native building block itself.
API publishing
Sim
OpenAI AgentKit
Yes: agents/workflows are consumed via the OpenAI API and can be embedded via ChatKit; Agent Builder itself is not a customer-facing REST API generator. Agents built with the Agents SDK run as regular application code that developers expose via their own APIs; ChatKit provides an embeddable chat surface rather than an auto-generated REST endpoint for a visual workflow.
SDKs & extensibility
Sim
OpenAI AgentKit
Agents SDK, Apps SDK, and app directoryOfficial Agents SDK (Python + TypeScript/JS); Apps SDK (MCP-based) for building integrations; ChatGPT Apps directory as a community marketplace. Agents SDK ships as open-source client libraries for Python (openai-agents-python) and TypeScript/JavaScript (openai-agents-js), provider-agnostic (works with 100+ LLMs via the Responses/Chat Completions APIs). Custom integrations are built as MCP servers using the Apps SDK, an open standard on the Model Context Protocol; Agent Builder's MCP node connects to any third-party MCP server. A Connector Registry centralizes admin-managed connectors (Dropbox, Google Drive, SharePoint, Teams) plus third-party MCPs. Community apps go through a dashboard-based submission and review flow and, once approved, are listed in the ChatGPT Apps directory.
Publish as MCP server
Sim
OpenAI AgentKit
No: publicly available evidence only shows AgentKit/Agent Builder consuming external MCP servers as tools (adding an MCP button and pointing it at OpenAI's or third-party MCP servers). There is no documented feature to publish a deployed Agent Builder workflow itself as a callable MCP server for external AI tools to consume.. A separate OpenAI product, the Apps SDK, discusses exposing an MCP app as a server, but that is not the same as publishing an Agent Builder workflow as an MCP server.
Observability & durability
Tracing & observability
Sim
Yes: execution logs include a per-block/per-span trace view (duration, cost, token counts, and latency stats like TTFT/TPS) with expandable nested iteration groups, plus a "View Snapshot" frozen copy of the workflow structure and block states at run time for debugging. This trace view is built directly into Sim rather than a raw export browsable in an external tool like Jaeger, and does not expose aggregate latency-percentile charts (p50/p95/p99). The run snapshot serves as a log-detail/debugging artifact rather than a resumable mid-run checkpoint.
OpenAI AgentKit
Yes: per-run tracing with spans (model calls, tool calls, handoffs, guardrails, custom spans) in a customer-facing Traces dashboard; no dedicated metrics dashboard (latency percentiles/error rates) documented. Tracing is on by default in the Agents SDK. Every run produces a structured trace with an ID, an optional group ID, and metadata tags, viewable in the Traces dashboard (Logs > Traces) for debugging and, via trace grading/agent evals, benchmarking. There's no aggregate metrics dashboard surfacing latency percentiles or error-rate trends across runs: official docs cover single-run trace inspection plus eval-based benchmarking, not a fleet-wide metrics view.
Durability & retries
Sim
Tool-call retries (up to 10x); single-attempt job orchestrationIndividual tool/API calls have configurable exponential-backoff retry (up to 10 attempts). The background job-orchestration layer itself retries only once by design. Durability instead comes from consecutive-failure tracking on schedules and the human-in-the-loop snapshot pause/resume mechanism. Sim does not offer guaranteed-once-only block execution, a failed-run holding queue for manual recovery, or a "replay a past execution with its original inputs" feature. The per-execution debugging snapshot serves as a log-detail artifact rather than a resumable mid-run checkpoint.
OpenAI AgentKit
Opt-in retries and checkpoint/resumeOpt-in retries, SDK-level checkpointing/resume of run state, but no one-click replay of a past production execution with original inputs from the Agent Builder UI. The Agents SDK supports configurable automatic retries on transient failures (network errors, rate limits, server errors), off by default and requiring an explicit retry policy. The SDK also records each run's execution state so it can resume after an interruption (e.g., pending tool approval) or a process restart, giving checkpoint/resume for fault tolerance. This is a developer-invoked mechanism in code, not a dashboard 'replay this failed execution' button, and there's no UI-driven replay-with-original-inputs feature for past runs.
Failure alerting
Sim
OpenAI AgentKit
No proactive alerting for failed runs or cost/latency thresholds. Traces are pull-based, inspected manually. The Traces dashboard records model calls, tool calls, handoffs, guardrails, and custom spans per run for after-the-fact debugging, but it's a manual inspection tool you open to debug a specific run. There's no built-in push notification (email/Slack/webhook) when a run fails or crosses a cost/latency threshold. Generic OpenAI platform webhooks exist for events like batch or fine-tuning job completion, but these aren't documented as covering Agent Builder/Agents SDK run failures or thresholds.
Data drains
Sim
Yes: Enterprise orgs can continuously export workflow logs, job logs, or audit logs on a schedule to a customer-owned S3 bucket, GCS bucket, Azure Blob container, BigQuery table, Snowflake table, Datadog logs intake, or an HTTPS webhook. Each drain exports exactly one data source; multiple drains are created to export multiple sources. Viewing drain config/run history is restricted to org owners/admins.
OpenAI AgentKit
Yes: OpenAI's Compliance Logs Platform and Admin/Audit Logs API continuously export execution, audit, and usage data as immutable, time-windowed JSONL log files, with 13 pre-built turnkey integrations to eDiscovery, DLP, and SIEM vendors (e.g. CrowdStrike, GlobalRelay), beyond just viewing logs in-product.. This is an org-wide ChatGPT Enterprise/API Platform compliance feature, not something scoped specifically to Agent Builder workflow runs.
Async execution
Sim
Yes: a workflow can be triggered in fire-and-forget async mode, returning HTTP 202 with a job ID immediately, then polled via a dedicated jobs endpoint through queued/processing/completed/failed states. Async jobs are tracked via polling the job endpoint rather than a completion webhook/callback option.
OpenAI AgentKit
Yes: OpenAI's platform supports a background mode that flags a Responses API call to run asynchronously instead of blocking. The client immediately gets back a response ID marked "queued" and polls a status endpoint until the run reaches a terminal state like completed or failed.. Background mode is a platform-level Responses API feature (used by Agents SDK/AgentKit flows), not unique to the Agent Builder canvas UI itself; an in-flight response can also be cancelled directly. Response data is retained only about 10 minutes for polling, and it is incompatible with Zero Data Retention projects.
Execution limits
Sim
5-50 min sync timeout, 90 min async, 15-300 concurrentPlan-gated: synchronous API calls time out at 5 minutes on the free plan and 50 minutes on paid plans, async calls at 90 minutes on every plan, with 15 to 300 concurrent executions per billing entity depending on plan. These limits are not published in docs; request bodies are separately capped at 10 MB.
OpenAI AgentKit
No published AgentKit-specific run/concurrency capsUnknown: OpenAI does not publish a fixed maximum duration for a single Agent Builder workflow run or Agents SDK execution, nor a concurrency cap specific to AgentKit. The only concrete numbers found are general API usage-tier limits (requests and tokens per minute/day, scaling from a $100/month allowance at Tier 1 up to $200,000/month at Tier 5) and a 300-requests-per-minute cap per vector store for file ingestion endpoints.. Background mode responses are only retained about 10 minutes for polling, a practical window for checking back on a run, but not a documented hard execution timeout. The one concrete node-level timeout is the Agent Builder Approval node, which times out after 5 minutes and alerts a supervisor if unactioned. Actual RPM/TPM caps are account/model-specific and only visible in the OpenAI dashboard.
Partial-failure handling
Sim
OpenAI AgentKit
No: Agent Builder has no dedicated try/catch or fallback-path construct for a failing step. Error handling has to be built manually with a Guardrails node (a pass/fail checkpoint on a prior node's output) combined with If/Else logic nodes to branch on conditions. OpenAI's own guidance for a guardrail failure is to end the workflow or loop back to the previous step, not to continue the rest of the run on a separate error path.. Guardrails nodes and If/Else logic nodes can be composed to approximate conditional routing around a failure, and a Human Approval node can pause for intervention, but none of these work as an automatic "catch this failing step and keep the rest of the run going" mechanism the way a dedicated error-handling path would.
Support
Support channels
Sim
Community support plus Enterprise 'Dedicated Support'Community (open source, GitHub) plus an unquantified "Dedicated Support" flag on the Enterprise plan. Enterprise and pricing pages do not include CSM, onboarding/enablement, or professional-services details beyond a plan-comparison-table "Dedicated Support" flag.
OpenAI AgentKit
Community forum plus 24/7 enterprise supportCommunity forum (community.openai.com), help center articles, and enterprise sales-led support; ChatGPT Enterprise includes 24/7 support. OpenAI's Help Center documents standard support channels, and ChatGPT Enterprise plans include 24/7 support with SLAs.
SLA
Sim
OpenAI AgentKit
Yes, for enterprise/Scale Tier customers. E.g., 99.9% uptime SLA on Scale Tier, and priority-processing SLAs with service credits. Scale Tier traffic offers a 99.9% uptime SLA with prioritized compute (available to Enterprise customers); Priority Processing customers on enterprise agreements can receive service credits if SLAs are missed. Exact SLA terms require contacting OpenAI sales.
Community
Sim
100,000+ buildersOver 100,000 builders use Sim
OpenAI AgentKit
27,500+ GitHub stars on Agents SDKOver 27,500 GitHub stars on the companion open-source Agents SDK (openai/openai-agents-python) as of 2026-07-02. A direct GitHub API check confirms roughly 27,600 stargazers for openai/openai-agents-python. This measures the Agents SDK's community, not Agent Builder/AgentKit specifically, since AgentKit's GUI components are closed-source SaaS.
Academy / training
Sim
OpenAI AgentKit
Yes: OpenAI Academy offers structured, free self-paced courses (AI Foundations, Applied AI Foundations, Agents and Workflows) plus official OpenAI Certifications (e.g. the AI Foundations certification backed by ETS and Credly), going beyond ad hoc docs or blog content.. Academy and Certifications are separate programs; course-completion certificates are not the same as formal OpenAI Certifications. This is a company-wide OpenAI offering, not specific to Agent Builder/AgentKit.
Sim standout features
AI Copilot / Chat agent-building surface
Chat and in-editor Copilot suggest and build workflow changes directly.
A natural-language surface (Chat) and in-editor Copilot that can explain, suggest, and build workflow changes directly, backed by a dedicated copilot module with its own tool registry.Hybrid semantic + keyword knowledge base
Combines vector and full-text search with configurable chunking across 11 file formats.
Built-in RAG with pgvector embeddings and a generated tsvector column for combined vector + full-text search, plus a token-based chunker with configurable chunk size/overlap and 11 supported file formats (csv, doc, docx, html, json, md, pdf, pptx, txt, xlsx, yaml).Native MCP client and server
Call external MCP servers as tools, or expose Sim workflows as an MCP server.
A dedicated MCP block lets any workflow call external MCP servers as a tool, and a serve/workflow-servers API surface lets Sim expose its own workflows as MCP servers.Fork a workspace into dev, qa, and prod environments
Fork, diff, and promote environments with mandatory credential remapping.
Fork a whole workspace into a dev/qa/prod-style child environment, preview a diff, and promote changes bidirectionally. Credential and env-var remapping is required on every promote, so secrets never cross environments silently.Human-in-the-loop approvals with durable resume
Pause a run for human approval and resume later via a durable snapshot link.
A dedicated block pauses a run and waits for a human-submitted approval form, backed by persisted execution snapshots so the run can resume later via a link, even after a server restart.Self-hostable under Apache 2.0
Fully open source with Docker Compose and Helm deployment options.
Fully open source (Apache 2.0), with Docker Compose files and a Helm chart for Kubernetes deployment, alongside a managed cloud-hosted option.Documented OpenAI AgentKit limitations
Agent Builder and Evals are being shut down
Visual builder and evals platform shut down November 30, 2026.
OpenAI announced in June 2026 that it is winding down Agent Builder (the visual no-code canvas) and the Evals platform. Evals goes read-only October 31, 2026, and both are fully unavailable November 30, 2026. The visual/no-code building experience central to AgentKit as originally announced is being discontinued in favor of the code-first Agents SDK or ChatGPT Workspace Agents.No self-hosted managed backend after winddown
Self-hosting requires running ChatKit on your own infrastructure entirely.
Once Agent Builder's managed hosting is discontinued, the only supported ChatKit integration path requires developers to run ChatKit on their own infrastructure via the Python SDK connected to a custom agentic backend. There is no OpenAI-hosted no-code deployment option remaining.Usage-based, per-token/per-call pricing with no published flat plan for AgentKit itself
No flat plan; costs scale with token and tool usage.
There is no dedicated AgentKit subscription tier. Costs are the sum of model tokens, Code Interpreter sessions ($0.03-$1.92 per session by memory tier), and File Search ($0.10/GB-day storage plus $2.50 per 1,000 tool calls), which makes cost forecasting harder than a flat, seat-based plan.Bottom line
Choose Sim if you want an open-source, self-hostable AI workspace that treats AI agents as first-class citizens: native multi-LLM support, real-time multiplayer editing, environment promotion (dev/qa/prod), human-in-the-loop approvals, and enterprise governance (SSO, credential-level permissions, audit logs) built in rather than bolted on.
Choose OpenAI AgentKit if you specifically need guardrails open-source safety layer: Agent Builder shipped an open-source, modular guardrails layer that can mask/flag PII, detect jailbreaks, and apply other safety checks around agent behavior.
Frequently asked questions
Sim is an open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. OpenAI AgentKit bundled a visual Agent Builder, ChatKit embeddable chat UI, Connector Registry, Guardrails, and Evals for building agentic workflows on OpenAI's models. But OpenAI is winding down Agent Builder and Evals, with full shutdown November 30, 2026, in favor of the code-first Agents SDK or ChatGPT Workspace Agents. Teams considering a switch typically weigh licensing (Sim is Apache 2.0 and self-hostable), pricing model, and how AI-native the platform's agent-building experience is.