Is 2025 the Year of AI Agents? Only If You Govern Them.

Author(s): Bran Kop, Engineer @Conformal, Founder of aiHQ

Originally published on Towards AI.

OpenAI’s AgentKit made a splash in late 2025, with some commentators hyping it as a potential “startup killer” for the AI agent space. It promises an integrated toolkit to build AI agents that can carry out complex tasks. But is AgentKit truly an all-in-one solution that renders other platforms obsolete? In reality, the AI agent ecosystem is vast and diverse, ranging from open-source visual builders to enterprise-grade orchestration platforms. Each has its niche, and AgentKit’s launch has only intensified the comparisons. This deep dive will examine what AgentKit offers, where it falls short (especially for enterprise needs), and how it stacks up against a myriad of alternative frameworks — from no-code agent builders to workflow orchestration tools. We’ll also look at which platforms are leading in adoption and what their competitive edges are in this rapidly evolving domain.

OpenAI AgentKit — A Developer-Centric Toolkit

AgentKit is best understood as a toolbox for developers to construct AI agents on OpenAI’s platform. It consolidates components that previously had to be cobbled together: logic flow design, tool integrations, data connectivity, testing, and a user interface. As OpenAI CEO Sam Altman put it, “AgentKit is a complete set of building blocks… to take agents from prototype to production… with way less friction.” In practice, this means AgentKit provides several key pieces out-of-the-box for building an agent:

• Agent Builder: a visual drag-and-drop canvas to design the agent’s workflow or “brain.” Developers can map out sequences of actions, tool calls, and decision logic on this canvas. It supports complex multi-agent or multi-step flows, although like any visual programming tool it can get messy for very large graphs.
• ChatKit: a front-end UI toolkit for embedding a chat interface. Rather than coding a chat window from scratch, developers can drop in ChatKit to let users converse with the agent. It’s customizable but still requires coding to integrate and style, so it’s meant for devs rather than end-users.
• Evals: an evaluation framework to test and measure agent performance. It lets developers run defined test datasets through agents and track how well they perform each step. This is crucial for debugging and refining an agent’s prompts or logic.
• Connector Registry & Guardrails: a system for integrating external tools/APIs and enforcing safety rules. The connector registry is a hub where one can register data sources or services (Google Drive, Slack, databases, etc.) that the agent may use. Meanwhile, “guardrails” are a set of open-source policies to prevent undesirable agent behavior (for example, avoiding certain actions or redacting sensitive info).

Notably, AgentKit is targeted at programmers and technical teams, not casual business users. It gives a lot of low-level control and flexibility — you can, for instance, write custom function definitions for the agent to call external APIs or define bespoke logic in code — but it presumes the user has coding skills. This is far from a no-code platform that a non-engineer could use directly. In fact, early demos showed that even with the visual Agent Builder, developers often needed to write Python code to implement custom tool functions or complex conditions. AgentKit is great for engineers who want to build highly customized AI agents from scratch, leveraging OpenAI’s GPT models and tools. It’s essentially an extension of the OpenAI API ecosystem, streamlined for agent creation.

What AgentKit Gets Right: It lowers friction for developers in a few ways. First, everything is in one place under OpenAI’s umbrella — no need to manually integrate separate libraries for chaining LLM calls, tool use, evals, etc., since those building blocks are provided. Second, the visual canvas can accelerate prototyping of an agent’s reasoning steps, especially for straightforward workflows. Third, ChatKit and the eval tools save development effort on the periphery tasks (UI and testing). And naturally, AgentKit’s tight integration with OpenAI’s model stack means it will support new OpenAI model capabilities immediately. For example, OpenAI’s new Model Context Protocol (MCP) for connecting tools is supported, and launch partners like the financial startup Ramp have used AgentKit to build bespoke agents (e.g. a procurement agent) quickly. AgentKit follows OpenAI’s standard API pricing (you pay only for model usage) with no extra license fee. This usage-based model is flexible for experimentation, though as we’ll discuss, it can become a budgeting headache at scale.

However, despite these strengths, business and enterprise users quickly noticed significant gaps. AgentKit in its initial form is “nowhere near what an enterprise actually needs to run agents in production,” as one industry commentator observed. Let’s explore those limitations.

Enterprise Needs vs. AgentKit’s Limitations

AgentKit’s first release makes clear that it is not an end-to-end enterprise solution but rather a developer framework. OpenAI essentially built a toolkit for engineers, leaving many production concerns out of scope. This has opened the door for specialized platforms to continue thriving. Key limitations of AgentKit include:

• Lack of Governance and Access Control: AgentKit currently has no built-in role-based access control (RBAC) or user permission system for what agents can do or who can modify them. In a business setting, this is critical — companies need to govern who can deploy or change an AI agent, and ensure agents operate within approved policies. Enterprise platforms like StackAI and IBM Orchestrate emphasize fine-grained access controls and audit logs (who ran what, when), whereas AgentKit offers nothing similar out-of-the-box. This makes AgentKit unsuitable for regulated industries where oversight is mandatory.
• No Compliance Certifications or Deployment Flexibility: OpenAI’s toolkit is cloud-based and tied to OpenAI’s services. It does not offer on-premises or private cloud deployment options — a non-starter for some banks, healthcare, or government users that require keeping data in-house. Likewise, compliance frameworks like HIPAA, PHIPA, or GDPR are not addressed explicitly by AgentKit. By contrast, enterprise-focused platforms advertise compliance: for example, StackAI supports HIPAA-compliant deployments and allows self-hosting for data privacy, and Cloudflare’s Workers AI/Agents can run in isolated environments on their global network for data locality needs. AgentKit’s one-size-fits-all cloud approach can be problematic where data governance is paramount.
• Limited Tool/Integration Library: Out-of-the-box, AgentKit only had about 19 connectors available via the new MCP tool registry. These include popular apps like Google Drive, Slack, and a handful of others. To connect anything outside this list, a developer must implement a custom function (essentially writing code for that integration). Competing platforms boast far broader integration libraries: 100+ pre-built connectors in some cases. For example, StackAI advertises one-click integrations with major enterprise systems (Salesforce, Zendesk, databases, etc.) so that non-developers can hook up data sources instantly. Similarly, Sim.ai (an open-source agent workflow builder) claims over 100 app connectors ready to use. AgentKit’s more sparse connector set and need for code mean higher effort to integrate with enterprise databases or proprietary tools.
• Model and Provider Lock-In: Perhaps unsurprisingly, AgentKit is restricted to OpenAI’s own LLMs (GPT-4, GPT-5, etc.) and tools. There’s no support for third-party LLMs or ML models in the AgentKit interface. This is fine for early prototypes, but enterprises often want a mix of models — for cost optimization, specialty domains, or simply to avoid vendor lock-in. In contrast, model flexibility is a selling point of other platforms: StackAI, for instance, lets you swap in Anthropic, Google PaLM/Gemini, open-source Llama-family models, or even on-prem models within the same workflow. Orkes (the company behind Netflix’s Conductor orchestration engine) similarly integrates OpenAI, Anthropic, Google, Mistral, Llama and more. AgentKit offering “OpenAI-only” agents is a limitation — especially if an organization has sensitive data and would prefer to use an in-house model or needs a specific model that performs better on a given task. OpenAI’s bet is that their models are the best, but the fast-evolving AI landscape means many organizations want optionality.
• Simplistic Logic/Control Capabilities: AgentKit’s visual workflow supports basic conditional logic (simple if/else branches and looping), but it lacks more advanced orchestration features. Real enterprise workflows often require dynamic routing of tasks, parallel branches that join later, error-handling paths, human approval checkpoints, etc. AgentKit can simulate some of this with multiple agents calling each other or by embedding code, but it’s not a full-fledged workflow engine. Competing orchestration tools emphasize this difference. For example, StackAI supports more nuanced routing and branching — one can route a customer query to different agent sub-flows based on topic, or escalate to a human if certain conditions are met. Orkes Conductor, being a general workflow platform, naturally handles complex branching, parallel tasks, retries, and long-running processes, which is its core strength. Even n8n (a general automation tool now used for AI agents) allows calling sub-workflows and merging results, giving a lot of flexibility in logic. In short, AgentKit’s logic handling is adequate for straightforward agents but may hit a wall with complex, enterprise-scale processes.
• Cost Predictability and Scaling: OpenAI’s usage-based pricing means that if your agent suddenly gets a lot of usage or runs very complex prompts, costs can spike unpredictably. For businesses trying to budget, this is a pain point — a flurry of customer queries could blow past the monthly budget, for example. Enterprise platforms often counter this with flat or tiered pricing. E.g., Eesel AI (a support-focused platform we’ll discuss later) offers fixed monthly plans for a certain number of agent interactions. This predictability is valued by enterprises. While not a functional limitation of AgentKit per se, the pricing model tied to API calls is something to manage carefully in production (some companies might choose to use smaller models or limit agent usage to control costs).

The upshot is that AgentKit is a powerful prototype-to-production toolkit for developers, but not a business solution. It accelerates building custom agents, yet leaves integration depth, security, and governance as an exercise for the user (or for other vendors to solve).

This is precisely why the notion that AgentKit would instantly kill off 100s of agent startups has proven overblown. In reality, most organizations will “hit a wall moving from demo to production,” and they’ll demand features that AgentKit doesn’t have (secure data handling, policy enforcement, compliance, user-friendly interfaces). Thus, rather than eliminating existing platforms, AgentKit’s launch highlights the different needs of different users. Individual developers and small teams might jump on AgentKit for quick projects, but enterprises still seek solutions that are enterprise-ready on day one.

No-Code and Visual Agent Builders

At the other end of the spectrum from code-centric AgentKit are the no-code or low-code platforms that aim to let users build AI agents with minimal programming. These include open-source projects and commercial tools that provide visual workflow builders for AI. They have been around and thriving, targeting either less technical users or faster prototyping. Let’s look at a few notable ones:

Example of a node-based visual workflow builder (Flowise). Here, an AI agent is configured with steps to fetch information and generate a summary. Visual no-code frameworks like Flowise provide drag-and-drop canvases to create LLM-powered agents without writing code.

• Flowise: An open-source platform for building AI agents and LLM workflows visually. It provides a web-based canvas where you can drag nodes representing actions (LLM prompts, tools, memory, etc.) and connect them to define an agent flow. Under the hood, Flowise leverages popular libraries like LangChain and LlamaIndex, but it wraps them in a user-friendly interface. Key features include support for sequential and multi-agent systems, Retrieval-Augmented Generation (for knowledge retrieval), and an extensive library of pre-built nodes/integrations. Flowise even lets you generate a chat interface widget from your flow to embed on a website. It has gained significant popularity; by 2025 it boasted thousands of stars on GitHub and was used by teams at AWS, Deloitte, and more (as per Flowise’s own website). Its success led to an acquisition by Workday in 2025, indicating the interest in no-code AI tooling. Importantly, Flowise markets itself as “enterprise ready” — supporting on-premises deployment (so you can self-host it behind your firewall) and horizontal scaling with worker nodes. For enterprises that want an internal tool for building agents quickly, this open-source option is appealing. The trade-off: visual flows can become complex for very large agents, and using Flowise still requires understanding AI concepts. Nonetheless, for rapid prototyping and for AI engineers who prefer a visual layout, Flowise and similar tools shine.
• LangFlow: Another open-source visual IDE, very similar in spirit to Flowise. LangFlow is built specifically on the LangChain Python framework. It presents LangChain’s components (LLMs, tools, chains, memory, etc.) as blocks you can wire together. This is great for those already familiar with LangChain — it basically saves you from writing boilerplate code and lets you tinker with chain designs in a GUI. LangFlow comes with some pre-built templates for common agent patterns, helping newcomers start quickly. Like Flowise, it’s primarily for developers (or technically inclined analysts) who want to visually design and test LLM-driven workflows. Both Flowise and LangFlow have community editions that are free, lowering the barrier to entry.
• Botpress: Botpress has been known for years as a popular open-source chatbot platform, and it has evolved to incorporate LLM agents. Botpress offers a browser-based studio with a visual flow builder. The emphasis is on building conversational agents (chatbots) that possibly integrate retrieval of information or external API calls. It provides templates and a “no coding required” experience for many use cases. For example, you can select a customer support bot template, define the bot’s knowledge base (by uploading documents or connecting a wiki), and deploy it to multiple channels (website chat, Messenger, etc.) with a few clicks. Botpress’s strength lies in this multi-channel deployment and its heritage in conversational design. It also has features like a built-in chat testing emulator and analytics. The core is open-source (an earlier version), with a cloud offering for convenience. Pricing is modest for small usage but scales up for enterprise volumes. Botpress is a representative of several “vertical” no-code tools — focused specifically on chatbots or specific domains (Ada, LivePerson, and other customer service AI bot platforms also fall here). They abstract away the details of LLM prompting behind more guided configurations.
• Sim (Sim.ai): A relatively new entrant (and Y Combinator-backed), Sim positions itself as an open-source alternative to n8n specifically for AI workflows. It offers a Figma-like drag-and-drop canvas to build agent workflows, and crucially, it comes with lots of pre-built integrations (100+ apps) and modular blocks. Sim emphasizes ease and speed — users have reported it’s “super easy and fast” to create an agent with Sim’s visual builder (reddit.com). It allows deploying the workflows as chatbots or as APIs easily. With over 30,000 developers using it (according to their site) and a growing open-source community, Sim is gaining traction. Essentially, Sim and similar tools are in direct response to AgentKit as well — in fact, an October 2025 blog from Sim compared “OpenAI AgentKit vs n8n vs Sim,” highlighting that Sim’s visual approach and open-source nature could be more flexible. The existence of Sim underscores that the market of visual builders is crowded — each trying to differentiate on usability or integration breadth.

The common theme among these no-code/visual frameworks is that they aim to empower users to build an agent without writing code. They hide the complexity of prompt orchestration behind configurable blocks. This lowers the entry barrier: a support manager or business analyst might configure a simple Q&A bot with these tools. However, to build a truly robust agent, some technical skill is still needed — you must understand the logic you’re creating, even if you’re not typing code. And, as we discussed, maintaining these flows can be challenging as they scale. That’s why some enterprise buyers prefer solutions that come pre-packaged with ready-to-use agents (we’ll get to that later) or ones that allow mixing code when needed.

Low-Code and Extensible Orchestration Platforms

Bridging the gap between no-code simplicity and full-code flexibility are the low-code platforms — those that offer visual workflows and the ability to inject custom code or logic as needed. Many of these platforms also emphasize connecting AI agents to existing business systems. Two notable categories here are general automation/orchestration tools that have added AI capabilities, and purpose-built agent orchestration frameworks that encourage extensibility.

• n8n: Among general workflow automation tools, n8n has emerged as a compelling option for AI orchestration. n8n is a popular source-available automation platform (an alternative to Zapier or Make.com) that introduced powerful AI nodes and templates. It provides an intuitive drag-and-drop interface to build workflows that can include calling AI models, transforming data, integrating with databases or APIs, etc. For example, in n8n you might create a workflow: trigger on a new support ticket → have GPT analyze the ticket text → if it’s a simple FAQ, auto-generate a response, otherwise route to a human and so on. Because n8n was built for general integration, it has many existing nodes for services (HTTP requests, Slack messages, database queries) and you can incorporate those into your AI agent’s actions. It also supports writing custom JavaScript code within the flow when needed for specialized logic. In terms of AI-specific features, n8n offers built-in nodes for popular LLM providers (OpenAI, etc.), memory management for chat context, and connectivity to vector databases for retrieval augmented generation. One notable aspect is n8n’s support for OpenAI’s MCP (Model-Context Protocol): n8n can act as an MCP client or server, meaning it can both call external tools via MCP and expose its own workflows as tools via MCP. This effectively allows n8n to plug into the AgentKit ecosystem or others using the MCP standard, giving it a leg up in interoperability. With flexible deployment options (cloud or self-hosted), n8n is attractive to enterprises concerned with data control. The platform is also well-funded (it raised $180M in 2023) and has a growing enterprise customer base. For developers, n8n hits a sweet spot: easier than coding everything from scratch, but not a black box — you maintain the ability to dive into code when necessary. Many developers likely see AgentKit as overlapping with what n8n already enabled, albeit n8n is model-agnostic and can integrate beyond the OpenAI universe.
• Sim, CrewAI, Rivet (Intermediate frameworks): We discussed Sim.ai in the no-code section, but it actually fits here too as an extensible open platform. Similarly, CrewAI and Rivet are frameworks that cater to developers wanting structure plus flexibility:
  — CrewAI is a Python-based framework allowing the creation of a “crew” of specialized AI agents working together. It provides a Studio interface (so some visual aspect) but focuses on the idea of role-specific agents (e.g. a Researcher agent, a Writer agent, an Editor agent collaborating on a task). CrewAI lets you define custom tools for agents and manage their interactions, which can be powerful for complex content generation or problem-solving workflows. It remains a niche but interesting approach, leaning into the multi-agent collaboration theme (inspired, perhaps, by early AutoGPT experiments).
  — Rivet is more of a developer tool — an IDE for building and debugging agent logic visually. It’s like a hybrid of a flow builder and a code environment. Rivet’s graph-based editor lets you step through an agent’s reasoning in real-time, see where things might go wrong, and adjust. It comes with a TypeScript library so you can execute the defined agent in production code after designing it. This appeals to developers who want transparency and fine control, and who might be frustrated by the “hidden magic” inside something like LangChain.
• LangChain and LangGraph: No discussion of agent frameworks is complete without mentioning LangChain, the open-source library that was almost synonymous with “LLM orchestration” in 2023. LangChain provides a programming-first approach — a set of APIs in Python/JavaScript to chain LLM calls, tools, and manage conversational memory. It enabled early agent use cases by offering abstractions for things like “Agents” that pick tools to use, or “Chains” that sequence prompts. However, LangChain garnered widespread criticism when developers tried to use it in real production systems. Common complaints were that it was fragile, hard to debug, and overly coupled to OpenAI’s models. Many found that beyond quick proofs-of-concept, LangChain’s abstractions would break down — errors were hard to trace, state management was weak, and it wasn’t built with enterprise deployment in mind. In response, newer projects like LangGraph emerged. LangGraph (developed within the LangChain ecosystem) is an orchestration framework that represents agent reasoning as structured graphs rather than linear chains. It aims to give more control over decision paths, incorporate long-term memory and human-in-the-loop checkpoints, and generally enforce more reliable execution. Essentially, LangGraph is tackling the same problem as Orkes or others but from a code-first angle: making LLM agent workflows deterministic and debuggable. It remains to be seen if LangChain/LangGraph will maintain their popularity as more user-friendly tools rise. Notably, Orkes (the company behind Conductor) directly compared itself to LangChain, noting that “most developers abandon (LangChain) for long-term projects” and pointing out its lack of reliability and integration in enterprise contexts. That signals that even open-source devotees are looking for more robust solutions.
• Cloudflare Workers AI/Agents SDK: An interesting development came from Cloudflare in mid-2025 with its Agents SDK for Cloudflare Workers. This is a code-centric framework that lets developers deploy AI agents onto Cloudflare’s serverless edge network. Cloudflare’s offering is quite technical but addresses some production needs: it provides stateful agents (backed by Cloudflare Durable Objects, meaning an agent can have persistent storage and long-running processes). It supports scheduling tasks, real-time communication via WebSockets (so agents can stream responses or maintain a conversation), and can integrate with any AI models or APIs you want. Essentially, Cloudflare gives you the canvas to write your agent as code (in JavaScript/TypeScript or Python) with full flexibility, then run it globally distributed for low latency. They even incorporate the new OpenAI MCP so that these agents can call tools or be exposed as tools in a standardized way. For developers who want maximum control and aren’t afraid to code, Cloudflare’s platform provides the “batteries-included” infrastructure: you get built-in state management, a database for the agent, automatic scaling to millions of instances, and so on. The drawback is you’re managing logic in code (no fancy UI), but for many engineers that’s preferable. We might consider Cloudflare’s entry as a competitor to using AgentKit on OpenAI — instead of being tied to OpenAI’s environment, one can build on Cloudflare and still call OpenAI’s models (or any model) from there. Cloudflare doesn’t offer the high-level eval or UI kits, but it offers raw power and enterprise-friendly deployment (Cloudflare has lots of enterprise customers and meets compliance standards). Time will tell how many adopt this, but it’s a compelling option for high-performance needs.

In summary, the developer-centric frameworks span from refined libraries (AutoGen, LangGraph) to full platforms (Cloudflare, Orkes). They cater to teams that have development capability and want either more reliability or flexibility than simpler tools provide. Many of these frameworks explicitly tout their enterprise-grade features — for instance, Orkes Conductor (and Orkes’ cloud offering) brings proven scalability and reliability from Netflix’s use, plus built-in human-in-the-loop support, monitoring, and security. Orkes emphasizes that it’s not just for AI but can “orchestrate end-to-end applications, APIs, and microservices in addition to AI agents,” which appeals to companies looking to integrate AI into their existing processes rather than treat agents as a standalone toy. It’s telling that over 3,000 companies already use the open-source Conductor engine — Orkes is trying to leverage that base to incorporate AI workloads.

For developers, the wealth of options means they can choose a stack that fits their needs: quick and easy (AgentKit, LangChain) for experiments, or robust and extensible (Cloudflare, Orkes, n8n) for mission-critical projects.

Enterprise-Grade Solutions and Market Leaders

Considering the limitations of AgentKit for enterprise scenarios, it’s no surprise that many enterprise-grade AI orchestration platforms continue to find demand. These are platforms specifically designed to meet corporate IT requirements: security, compliance, integration with legacy systems, user management, and so forth. Let’s highlight a few and see how they compete:

• StackAI: StackAI is a startup-born platform explicitly branding itself as “the enterprise AI agent toolkit.” It provides a no-code, drag-and-drop interface similar to some tools above, but its distinguishing feature is a strong focus on enterprise governance, security, and domain-specific solutions. StackAI comes with dozens of pre-built agent templates for common enterprise workflows (e.g. finance approval flows, HR onboarding assistants, legal document analyzers). This means a team can start with a blueprint rather than a blank canvas — a huge time saver. It integrates out-of-the-box with popular enterprise software (from CRMs to databases) with 100+ connectors. Most importantly, it has rich governance features: fine-grained RBAC (roles like Admin, Editor, Viewer with permissions on projects), group-based access (so different departments can have their own workspaces), version control for workflows, and an approval workflow for changes. Compliance-wise, StackAI emphasizes options for HIPAA compliance for healthcare, data retention policies, and audit logs of agent actions. Unlike AgentKit, which only logs what the model does in a limited way, StackAI’s Management Hub gives a full history of agent runs, errors, and usage metrics — crucial for debugging and audits. It’s also model-agnostic; enterprises can plug in OpenAI models or others (including their own hosted models) within the same agent. And they support both cloud and on-prem deployments. Essentially, StackAI is trying to be the safe, controlled environment where a large company can build AI agents that actually interface with internal systems and operate under oversight. It directly contrasts itself with AgentKit on every point: where AgentKit has only basic logic, StackAI offers advanced workflows; where AgentKit has limited connectors, StackAI has many; where AgentKit has no UI for end-users except a basic chat, StackAI lets you deploy agents as web apps, Slack bots, etc., with custom branding. Because of this focus, StackAI doesn’t see AgentKit as killing its market — rather it validates the need for agent tools, and StackAI fills the enterprise gap AgentKit left. They’ve reported customers like HP and others in regulated industries using their platform.
• Eesel AI: Eesel AI (from which I cited a detailed guide earlier) is another example of an enterprise-friendly agent platform, albeit focused on customer support use cases. Eesel’s approach is to give support teams a no-code dashboard to set up AI agents that can handle support tickets or answer questions using the company’s knowledge bases. It emphasizes quick deployment (minutes, not weeks) and integration with existing helpdesk software like Zendesk or Freshdesk via one-click connectors. In Eesel, a support manager can connect data sources (past tickets, FAQ docs), define the agent’s “personality” or tone in plain English, and then test it on historical tickets using a Simulation Mode. The Simulation Mode is particularly noteworthy: it runs the AI on thousands of past tickets to show what it would have answered, and calculates what percentage would be resolved, etc., all before going live. This approach to validation is very business-oriented (focused on outcomes and accuracy on real data rather than abstract metrics), contrasting with AgentKit’s dev-focused Evals. Eesel also has built-in guardrails and prompt controls that a non-developer can adjust (for example, defining when the AI should escalate to a human, or what it should never say). Essentially, Eesel is positioning as “AgentKit for business users.” In their comparison, they note that AgentKit’s unpredictable API costs and need for coding make it impractical for support teams who just want a working solution. Eesel offers predictable SaaS pricing and targets specific ROI (like deflect X% of tickets). While Eesel is narrower in scope (customer support primarily), it exemplifies how vertical-specific agent platforms can compete by being turnkey solutions. We can expect to see similar specialized platforms in IT operations, sales, finance, etc., where they package domain knowledge with AI.
• IBM watsonx Orchestrate: When it comes to big enterprise vendors, IBM has entered the arena with watsonx Orchestrate (launched around mid-2023 and evolving since). IBM’s offering is pitched as an “open solution, fully orchestrated, to bring all your AI agents together”. It focuses on large organizations that may have multiple AI assistants and automation tools and want to manage them centrally. Watsonx Orchestrate includes a no-code Agent Builder (for creating new AI agents or skills), a catalog of pre-built agents and tools, and strong governance and observability features. For example, IBM provides 100+ domain-specific pre-built agents and 400+ pre-built tools/integrations out of the box — these could be things like a sales lead qualification agent, or an HR FAQ agent, each pre-integrated with common systems. The platform emphasizes that it’s business-ready: you can deploy agents quickly that work with your existing software (no “rip and replace”). In terms of governance, IBM Orchestrate offers a “security-rich environment with centralized oversight, guardrails and automated policy enforcement” (ibm.com). This means admins can set policies (for instance, an agent cannot send certain data outside, or must escalate certain types of requests) and the system will enforce them. It also supports multi-agent orchestration — coordinating several specialized agents to work on parts of a process. IBM’s approach leverages its long experience in business process management (BPM) and automation. Essentially, it’s pitching to CIOs: “We unify your chatbots, RPA bots, and AI agents under one orchestrator with enterprise-grade control.” IBM’s credibility in trust and its existing client relationships (some early case studies include Dun & Bradstreet, and even IBM’s HR department using Orchestrate to resolve 94% of HR requests automatically) give it a foot in the door. If we consider “market share” in terms of Fortune 500 penetration, IBM could quickly gain ground simply via its enterprise sales force hooking Orchestrate into large accounts. It may not be the choice of individual developers, but for large-scale deployments, many companies will turn to established vendors like IBM for support and accountability.
• UiPath and RPA Vendors: A major angle in the enterprise automation story is the convergence of AI agents with RPA (Robotic Process Automation). UiPath, a leader in RPA, has aggressively embraced what it calls “Agentic Automation.” In September 2025, UiPath announced an expanded platform that integrates AI agents into its automation suite. They introduced an AI Agent Builder (visual canvas) within UiPath Studio, enabling low-code creation of agents with debugging tools, templates, and integration with communication channels like Teams and Slack. They also have “Coded Agents” for developers, with support for OpenAI’s MCP to plug into external services. Critically, since UiPath already provides orchestration (via its Orchestrator/Maestro) for running automations at scale with full governance, they extended that to AI agents. The UiPath platform now boasts built-in security, governance and compliance for agents, meeting enterprise standards. In other words, they combine the reliability of RPA (deterministic workflows, transaction logs, error handling, etc.) with the flexibility of AI. They also offer pre-built industry solutions — for example, packages for financial services or healthcare that combine AI with traditional automation for specific processes (like loan processing or claims handling). Considering UiPath’s enormous enterprise customer base (thousands of companies already use UiPath for automation), their pivot to include AI agents is significant. They can immediately distribute AI capabilities to those customers through updates. This likely gives UiPath (and similarly Automation Anywhere, which is also adding AI features) one of the largest enterprise reaches in this space. Rather than building from scratch, many enterprises might prefer to extend a system they already trust (RPA) to handle AI tasks, rather than adopt a completely new platform. It’s a different paradigm — RPA bots excel at structured, repetitive tasks, whereas AI agents bring unstructured reasoning — but together they cover end-to-end processes. We can expect RPA vendors to be major players, possibly overshadowing smaller startups in the large enterprise segment due to this advantage.
• Other Notables: Beyond the ones above, there are many others each carving a niche:
  — Orkes / Netflix Conductor — as discussed, focusing on complex workflow orchestration including AI, appealing to companies that need extreme reliability and customizability. Orkes’ strength is being proven at “Netflix scale” and offering polyglot support (developers can use Java, Python, etc. with it). They are likely to attract tech-savvy organizations that want full control plus enterprise features like RBAC and audit logs.— Microsoft’s Power Automate/Logic Apps — Microsoft is integrating Azure OpenAI into its Power Platform, potentially allowing business users to include GPT-based steps in their workflows. There’s also Semantic Kernel (open-source) and AutoGen for developers on Azure, indicating Microsoft’s ecosystem will have both low-code and code solutions tightly integrated with Azure services (and Office 365 data). Given Microsoft’s massive enterprise footprint, this is another channel through which AI agents will be deployed widely, albeit under Microsoft’s guardrails.
  — Vertical AI Assistant Platforms — e.g., Moveworks (IT support agent), Forethought (customer support AI), Adept (general task automation AI), etc. These often provide pre-trained agents for specific domains. They might not call themselves “agent frameworks” because they deliver a ready product (like an AI that can reset passwords via IT systems). However, from a competition standpoint, if an enterprise’s goal is say “automate Level-1 IT support,” they might choose a turnkey product like Moveworks rather than assemble an agent with AgentKit or StackAI. So these are indirect competitors, solving the same problems via a product instead of a platform.

When it comes to market share and leaders, it’s early to declare winners, but we can infer a few things:

• In terms of developer adoption and mindshare, open frameworks like LangChain had huge buzz (tens of thousands of GitHub stars) and AgentKit now has a lot of attention among the AI developer community. However, developer buzz doesn’t directly equal production usage. Many developers experimented with AutoGPT-like agents in 2023, but those experiments rarely made it into production business processes. The trend since then is toward more structured, reliable frameworks (which is why n8n, Orkes, etc., emphasize that they won’t hallucinate a workflow to failure the way an unconstrained agent might).
• For enterprise deployments, companies with established relationships and proven track records have an edge. That points to UiPath (and other RPA firms), IBM, and possibly Microsoft and Salesforce (Salesforce has its Einstein platform which may integrate agents into CRM). These players can rapidly distribute AI agent capabilities to their installed base, which is a huge market advantage. A press release from UiPath described their agentic automation as “all with built-in security and governance” to meet international standards, clearly targeting enterprise CIO checkboxes. So while a startup like StackAI might have the coolest features, a cautious enterprise might buy from UiPath or IBM for the support and integration benefits.
• Among the startups and independent platforms, those focusing on enterprise-grade needs are more likely to survive the AgentKit wave. StackAI, for one, is directly addressing the gaps of AgentKit and appears to be gaining customers in finance and other regulated sectors. Orkes, with its strong technical foundation, could become a behind-the-scenes orchestrator for many companies (some might even use Orkes in conjunction with AgentKit — e.g., using AgentKit to build an agent’s logic, but using Orkes to run and monitor it with other processes).
• Open-source projects like Flowise, LangFlow, Sim have a bright future especially if backed by enterprise sponsors (Flowise now has Workday’s backing). They could either become the basis of internal tools or be commercialized as services. Their strength is the community and flexibility — companies can tailor them as needed without vendor lock-in, which is a big plus for some developers.
• Cloudflare’s entry suggests cloud infrastructure providers also want a piece of the pie — we might see AWS or others do something similar (AWS has tools like Step Functions and Bedrock for AI, but not a unified agent toolkit yet; they might in time). Cloudflare’s competitive edge is performance and a developer-friendly pricing (many of their services are inexpensive or usage-based at fine granularity), which could attract the web developer crowd for certain use cases (like real-time interactive agents on websites).
• AgentKit’s future: It’s worth noting that OpenAI could iterate rapidly on AgentKit to address some shortcomings. For example, they might introduce basic role management, or more connectors, or even allow approved third-party models someday if customers demand it. If OpenAI starts adding enterprise features to AgentKit, it could encroach on the startups’ territory. But historically, OpenAI has focused on the core model/API business and left a lot of application-layer needs to the ecosystem. As of late 2025, AgentKit seems content being a developer tool, and OpenAI likely views the likes of StackAI or Eesel as partners filling gaps (OpenAI benefits as long as people use its models underneath).

In summary, rather than a single winner, we’re seeing different leaders for different segments:

• For developers/hobbyists: AgentKit, LangChain remain popular, as does the n8n + custom code approach, because of their flexibility and low barrier to try out.
• For enterprise IT teams: Platforms like StackAI, Orkes, and IBM Orchestrate are compelling due to governance and integration. RPA-based solutions (UiPath) also stand out as likely dominant players in large organizations, since they combine AI with existing automation and come with trust.
• For specific domains: Vertical solutions (like support-focused Eesel or IT-focused Moveworks) might “win” within their niche by offering out-of-the-box value that general platforms can’t match without a lot of configuration.

One thing is clear: AgentKit did not kill the agent platform ecosystem — it energized it. The real story is that most organizations will quickly outgrow what AgentKit alone can offer when moving from a demo to a full production rollout. Each competitor is doubling down on what makes them unique (be it ease-of-use, compliance, or integration breadth). For the foreseeable future, we expect a multi-platform landscape where:

• OpenAI AgentKit drives innovation and standardization (like the MCP tool interface) and serves as a stepping stone for custom development,
• while specialized platforms ensure that AI agents can be deployed safely, at scale, and in alignment with business needs. The winners in terms of market share will likely be those who manage to combine the power of generative AI with the practical requirements of enterprise software — delivering AI agents that are not only smart, but also reliable, secure, and deeply integrated into the workflows that run businesses.

References:

(1) OpenAI — AgentKit launch page. OpenAI
(2) Cloudflare — Remote MCP & Agents SDK announcement. Cloudflare
(3) Cloudflare — MCP + Durable Objects technical deep dive. The Cloudflare Blog+1
(4) IBM — watsonx Orchestrate updates (governance/observability). IBM+1
(5) UiPath — agentic automation platform news. UiPath+1
(6) StackAI Blog — “StackAI vs OpenAI AgentKit” (Oct 2025). stack-ai.comstack-ai.com
(7) Orkes (Netflix Conductor) documentation and comparison to LangChain. orkes.ioorkes.io
(8) n8n Blog — “9 AI Agent Frameworks Battle: Why Developers Prefer n8n”. blog.n8n.ioblog.n8n.io
(9) FlowiseAI (Workday) platform page. flowiseai.comblog.n8n.io
(10) Sim.ai open-source project description. sim.ai

Published via Towards AI