Recommended Free Tools
OpenAI AgentKit is a toolkit for building, deploying, and improving AI agents. It combines a visual workflow builder, centralized tool and data connections, an embeddable chat interface, and evaluation features. The main choice for developers is whether to prototype visually with Agent Builder or build directly in the code-first Agents SDK; OpenAI’s published lifecycle changes make that decision important for projects launching in 2026.
What is OpenAI AgentKit?
OpenAI announced AgentKit on October 6, 2025, as a set of tools for developers and enterprises. It is not a single agent runtime or one API. Instead, it covers the main stages of an agent project: designing workflows, connecting data and tools, embedding an interface, and measuring quality.
- Agent Builder: A visual, node-based canvas for composing and versioning multi-agent workflows.
- Agents SDK: A code-first framework that runs in your application and supports agents that plan, use tools, collaborate, and retain context.
- ChatKit: A customizable, embeddable chat experience for putting an agent into a product.
- Connector Registry: A central administration layer for data and tool connections across OpenAI products.
- Evaluation features: Datasets, trace grading, automated prompt optimization, and support for third-party models.
These pieces are complementary. A team can design a workflow, connect approved systems, expose it through a chat interface, and then use traces and evaluation data to improve it.
How the AgentKit pieces fit together
- Design the workflow. In Agent Builder, nodes and connections define sequence and control flow. In the Agents SDK, the same kind of orchestration is expressed in application code.
- Provide capabilities. Agents can use hosted tools, function tools, or MCP integrations. Connector Registry can give administrators a common place to manage approved connections.
- Choose the user experience. ChatKit supplies a ready-to-embed conversational interface, while a team can build a completely custom interface around its own application.
- Run and observe. SDK tracing and workflow previews show what an agent did, which tools it called, and where a result may have gone wrong.
- Evaluate and iterate. Datasets, trace grading, and automated prompt optimization are intended to turn observed failures into repeatable improvement work.
Agent Builder vs. the Agents SDK
Agent Builder is aimed at visual composition and rapid iteration. The Agents SDK is aimed at developers who need source-code control and application-level ownership.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
| Decision area | Agent Builder | Agents SDK |
|---|---|---|
| Workflow control | Visual nodes and connections define sequence and flow. | Application code defines orchestration, branching, tools, and state handling. |
| Versioning and migration | Workflows can be created and versioned on the visual canvas; the official cookbook demonstrates exporting a workflow toward SDK code. | Changes are managed with the developer’s normal source-control and deployment process. |
| Hosting responsibility | The workflow is built and run on the OpenAI platform while the product is available. | The SDK runs in the developer’s application, so deployment, scaling, secrets, and runtime operations remain with that team. |
| Integration flexibility | Works with configured connections and the tools exposed by the workflow environment. | Supports hosted tools, function tools, MCP integrations, and application-specific code. |
| Testing and observability | Provides a preview-oriented visual development path and connects to the evaluation workflow. | Includes tracing and can be paired with datasets, trace grading, and automated prompt optimization. |
| Lifecycle risk | OpenAI has announced an end-of-availability date of November 30, 2026. | No retirement date is stated in the cited material; OpenAI recommends it for workflows that should continue as code. |
When Agent Builder makes sense
- You need to sketch a multi-step or multi-agent flow quickly.
- Product, operations, and engineering stakeholders need to inspect the workflow visually.
- You want to preview behavior before committing to a code implementation.
- You expect to use the visual version as a starting point for an SDK implementation.
When to start with the Agents SDK
- The workflow must live inside an existing service, application, or deployment pipeline.
- You need custom control over state, retries, authorization, tool selection, or business logic.
- Your team requires ordinary code review, automated tests, and source-controlled releases.
- The workflow is expected to remain in service beyond Agent Builder’s announced availability window.
Can you embed an AgentKit agent in an app?
Yes. ChatKit is the principal interface layer described in the launch materials. It provides a customizable chat UI that can be embedded in a product rather than forcing users into a separate OpenAI-hosted screen.
| Interface choice | Time to embed | Customization | Operational ownership |
|---|---|---|---|
| ChatKit | Shorter path because the chat experience is provided as a toolkit. | Customizable within ChatKit’s supported experience. | You integrate and operate the surrounding application while using the provided chat layer. |
| Fully custom UI | Longer implementation because you build the conversation surface and interaction states. | Maximum control over layout, navigation, accessibility, and non-chat interactions. | Your team owns the interface, streaming behavior, error states, telemetry, and ongoing maintenance. |
ChatKit is useful when the product needs a conventional conversational entry point. A custom interface is preferable when an agent is only one part of a larger workflow, such as a dashboard, editor, or case-management system.
What is Connector Registry?
Connector Registry is the administration layer for data and tool connections used across OpenAI products. The launch materials list prebuilt connectors for services including Dropbox, Google Drive, SharePoint, and Microsoft Teams, along with third-party MCP connections.
The important distinction is governance. Instead of configuring every connection independently inside every workflow, an organization can manage available connections centrally and decide which agents or teams may use them.
| Connection strategy | Governance | Access control | Maintenance |
|---|---|---|---|
| Connector Registry | Central administration across OpenAI products. | Connections can be managed as shared organizational resources. | Common connector administration can reduce duplicated setup as workflows grow. |
| Direct function or MCP integration | Governance is implemented in each application or integration layer. | The developer controls authorization and policy in code or the selected MCP service. | Each integration’s credentials, compatibility, and updates must be maintained by the responsible team. |
Registry-managed access does not remove the need to define least-privilege permissions, review data handling, and monitor what an agent can do. It provides a centralized place to apply those decisions.
How AgentKit evaluation works
Agent quality cannot be judged only by whether one preview run produces a plausible answer. AgentKit’s evaluation direction combines representative examples with execution traces and automated improvement.
Datasets
Datasets give a team a repeatable set of inputs and expected outcomes. For a career-development agent, examples could include resumes with different experience levels and skill gaps, together with the qualities a useful recommendation should contain.
Trace grading
A trace records the agent’s execution, including intermediate steps and tool activity. Trace grading lets a team assess the path taken, not just the final text. That helps reveal problems such as an incorrect tool call, missing context, or an unnecessary handoff between agents.
Automated prompt optimization
Prompt optimization uses evaluation results to suggest or test prompt changes. It is an iteration aid, not a substitute for defining what success means or reviewing high-impact failures.
Third-party model support
The launch describes evaluation support for third-party models. This allows teams to compare behavior across supported model choices using the same evaluation approach rather than relying on informal spot checks.
A practical AgentKit workflow
OpenAI’s official cookbook demonstrates a career-development use case that analyzes resumes, identifies skill gaps, and recommends online courses. The sequence illustrates a practical build-and-improve loop:
- Map the task. Separate resume analysis, skill-gap identification, and course recommendation into clear stages.
- Compose the flow. Build the stages and their connections in Agent Builder.
- Preview representative inputs. Run the workflow with resumes that vary in format, experience, and missing information.
- Export toward SDK code. Use the demonstrated export path when the workflow needs to move into a code-owned application, then review the generated implementation rather than treating it as production-ready without testing.
- Embed the experience. Use ChatKit when a conversational interface fits the product, or connect the SDK to a custom UI.
- Close the quality loop. Turn representative cases into a dataset, inspect traces, grade outcomes, and refine prompts or workflow logic.
AgentKit’s 2026 lifecycle and migration implications
OpenAI’s June 3, 2026 update says Agent Builder and Evals will no longer be available on the OpenAI platform after November 30, 2026. The current node reference repeats that date. ChatKit remains available.
OpenAI recommends the Agents SDK for workflows that should continue as code, and Workspace Agents in ChatGPT for use cases better suited to natural-language prompting. This creates three practical paths:
| Your situation | Recommended direction |
|---|---|
| You are experimenting with a visual workflow before implementation. | Use Agent Builder while available, then validate an SDK version before the shutdown date. |
| You operate a production workflow in an application. | Adopt or retain the Agents SDK and keep deployment, tests, and integrations under application source control. |
| You need a prompt-driven assistant for a workspace rather than an embedded product feature. | Evaluate Workspace Agents in ChatGPT. |
| You need an embedded conversational surface. | Continue evaluating ChatKit; its availability is not included in the Agent Builder shutdown notice. |
Migration checklist for an Agent Builder project
- Record the workflow’s nodes, connections, prompts, tools, permissions, and expected outputs.
- Export toward Agents SDK code where the workflow supports that path.
- Recreate secrets, authentication, data access, retries, and error handling in the application environment.
- Build a dataset from real, permissioned cases and compare SDK results with the visual workflow.
- Inspect traces for tool calls, handoffs, and missing context before switching traffic.
- Plan the cutover before November 30, 2026 rather than treating the shutdown date as a testing deadline.
Choosing an AgentKit path
- Choose Agent Builder first for visual discovery, stakeholder review, and a short path to a working prototype.
- Choose the Agents SDK first when the workflow is already a software product, needs deep integration, or must remain code-owned.
- Choose ChatKit when you want an embeddable conversational interface without building every chat interaction yourself.
- Choose a custom UI when the agent must fit a specialized product workflow or non-chat interaction model.
- Use Connector Registry when centralized administration of shared connections matters; use direct tools or MCP when the application needs bespoke integration control.
- Use evaluation and tracing from the beginning for any agent whose mistakes affect decisions, customer service, access to data, or downstream automation.
The bottom line
AgentKit’s value is its end-to-end coverage: visual workflow design, code-first execution, managed connections, embeddable chat, and systematic evaluation. For new developer projects, the safest long-term architecture is usually to treat Agent Builder as a prototyping aid and the Agents SDK as the code-owned destination, while using ChatKit and Connector Registry where their interface and governance benefits fit. The November 30, 2026 end-of-availability date for Agent Builder and Evals should be part of the project plan from day one.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
