diff --git a/apps/sim/content/library/ai-agent-orchestration-frameworks-explained/index.mdx b/apps/sim/content/library/ai-agent-orchestration-frameworks-explained/index.mdx
new file mode 100644
index 00000000000..87fdc1afc48
--- /dev/null
+++ b/apps/sim/content/library/ai-agent-orchestration-frameworks-explained/index.mdx
@@ -0,0 +1,121 @@
+---
+slug: ai-agent-orchestration-frameworks-explained
+title: 'AI Agent Orchestration Frameworks Explained'
+description: 'Learn how AI agent orchestration frameworks coordinate models, tools, state, and control flow, and compare code-first, visual, and provider-native approaches.'
+date: 2026-08-19
+updated: 2026-08-19
+authors:
+  - andrew
+readingTime: 8
+tags: [AI Agents, Agent Orchestration, Workflow Automation, Sim]
+ogImage: /library/ai-agent-orchestration-frameworks-explained/cover.jpg
+canonical: https://www.sim.ai/library/ai-agent-orchestration-frameworks-explained
+draft: false
+faq:
+  - q: "How does agent orchestration differ from workflow automation?"
+    a: "Agent orchestration coordinates model reasoning, tool use, state, and control flow across one or more agents. Workflow automation primarily executes predefined steps. Modern systems can combine both approaches: models handle decisions that require context, while deterministic branches, loops, validations, and approvals govern predictable or sensitive actions."
+  - q: "Do agent orchestration frameworks require code?"
+    a: "Agent orchestration frameworks may use code, visual graphs, or natural-language instructions. Sim supports a visual canvas, natural-language building through Mothership, and programmatic interfaces. You can choose direct code control or build faster without writing every component yourself."
+  - q: "How does MCP fit into agent deployment?"
+    a: "MCP provides a standard way for AI systems to discover and call external tools. Sim can connect to external MCP servers and publish deployed workflows as MCP tools. You can make one workflow available to compatible assistants without building a separate integration for each one."
+  - q: "How do open-source, fair-code, and proprietary licenses differ?"
+    a: "Open-source licenses generally permit inspection, modification, and redistribution under stated conditions. Fair-code licenses make source available but may restrict some commercial uses, while proprietary licenses reserve broader control for the vendor. Review the exact license and enterprise terms before embedding a framework, offering it commercially, modifying it internally, or committing to a hosting model."
+---
+
+## TL;DR
+
+An AI agent orchestration framework is software that coordinates agents, models, tools, state, and control flow so they can complete multi-step work.
+
+- **Code-first frameworks** such as [LangGraph](https://docs.langchain.com/oss/python/langgraph/overview) give you direct control over orchestration logic in code.
+- **Model-vendor-native stacks** such as the [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) integrate closely with one provider's models and tooling.
+- **Visual and natural-language builders** such as Sim let you combine agent reasoning, explicit workflow logic, and code in one graph. Sim sits in this visual and code hybrid category.
+
+[Start building with Sim](https://sim.ai).
+
+## What an AI agent orchestration framework is
+
+An AI agent orchestration framework is software for defining how AI agents, models, tools, and human input work together across a task. It coordinates each step while preserving context, routing work, and controlling what happens next.
+
+Orchestration adds a runtime that single prompts and plain automation lack. A single prompt usually produces one response, while conventional automation follows a fixed sequence of predefined actions. An orchestration runtime tracks state across steps and uses a graph to represent the available actions and transitions. This combination is also central to an [agentic workflow](https://www.sim.ai/library/what-is-an-agentic-workflow).
+
+Most frameworks provide four core primitives. State stores messages, tool outputs, and other context that later steps need. Tool calling lets an agent query data or act through external systems. Control-flow operators route work and repeat steps, while approval nodes pause execution for human review. A deployment surface exposes the completed workflow through an API, chat interface, MCP server, or background job.
+
+Builders usually choose an approach based on how much infrastructure and control they want to own. Code-first frameworks expose orchestration logic directly, while visual and natural-language builders package it into an editor and managed runtime. Model-vendor-native stacks offer tighter integration with one provider's models and tool conventions.
+
+## The three ways teams build agent orchestration
+
+Code-first frameworks give you detailed control over agent state and execution, but you must write and maintain the surrounding infrastructure.
+
+Visual and natural-language builders speed up development while preserving varying levels of control over branches, loops, and approvals.
+
+Model-vendor-native stacks provide tight integration with one provider's models and tools, but they can limit model choice and increase ecosystem lock-in.
+
+### Code-first frameworks: LangGraph and CrewAI
+
+Code-first frameworks let engineers express agent orchestration directly in software, which gives them detailed control over state, routing, retries, and tool calls. They suit projects that need custom runtime behavior or must fit an existing application architecture. Engineers also gain access to normal development practices such as version control, automated tests, and code review.
+
+[LangGraph models an agent workflow as a stateful graph](https://docs.langchain.com/oss/python/langgraph/graph-api). Nodes run model calls, tools, or application logic, while edges determine which node runs next. A shared state object carries information between nodes. Because the graph can contain branches and cycles, LangGraph supports repeated reasoning, [human-in-the-loop interrupts](https://docs.langchain.com/oss/python/langgraph/interrupts), and long-running processes without forcing every decision into one prompt.
+
+[CrewAI organizes multi-agent orchestration](https://docs.crewai.com/en/concepts/crews) around agents with defined roles, goals, and tools. A crew assigns tasks to agents and controls how they collaborate, while [CrewAI Flows](https://docs.crewai.com/en/concepts/flows) add event-driven steps and state management around that collaboration. The role-based model works well when a workflow maps naturally to specialists, such as a researcher passing findings to a writer.
+
+The open-source frameworks do not provide a complete application by themselves. You may still need to assemble an end-user interface, deployment infrastructure, authentication, integrations, and production monitoring. [LangGraph Platform](https://docs.langchain.com/langgraph-platform/overview) and [CrewAI Enterprise](https://docs.crewai.com/en/enterprise/introduction) offer related services and tooling, but adopting those products introduces additional architecture and operating choices.
+
+Sim takes a different approach by packaging visual and natural-language building, deployment, and execution logs in one workspace. That approach can shorten the path between a prototype and an inspectable deployed system, while code-first frameworks preserve more control over implementation details. For a closer look at the tradeoffs, see these [LangGraph alternatives](https://www.sim.ai/library/langgraph-alternatives).
+
+### Visual and natural-language workflow builders: n8n, Make, Zapier, and Sim
+
+Visual and natural-language workflow builders let you assemble orchestration on a canvas instead of defining every state transition in code. You connect triggers, actions, branches, loops, and AI steps as blocks. Some products also let you create or edit those blocks through natural-language instructions.
+
+[n8n](https://docs.n8n.io/flow-logic/) and [Make](https://help.make.com/scenario-editor) center their builders on visual app automation, while [Zapier](https://help.zapier.com/hc/en-us/articles/8496181725453-Create-Zaps) uses trigger-and-action workflows. A trigger starts a predefined sequence, and each node processes data or calls another application. Their respective [AI Agent](https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/), [Make AI Agents](https://help.make.com/make-ai-agents-new), and [Zapier Agents](https://help.zapier.com/hc/en-us/articles/30219476645645-Create-an-agent-in-Zapier-Agents) features add model decisions, tool use, and generated outputs within those products. Explicit flow controls govern what happens around each AI step.
+
+Sim gives model reasoning a first-class role within the same graph as deterministic control. A [Sim workflow](https://docs.sim.ai/introduction) can combine Agent blocks with functions, conditions, routers, loops, parallel branches, integration actions, and human approval. You can therefore reserve model judgment for tasks such as classifying a request while using fixed logic for validation, routing, and sensitive actions.
+
+[Mothership](https://docs.sim.ai/mothership) adds natural-language control across the Sim workspace. You can ask it to create or modify workflows, work with tables and files, connect knowledge bases, and set up recurring jobs. The visual canvas remains available for inspecting the resulting graph and adjusting individual blocks.
+
+Sim also connects orchestration to deployment. According to its [deployment documentation](https://docs.sim.ai/workflows/deployment), a versioned workflow can run through a REST API or hosted chat, and its [MCP deployment](https://docs.sim.ai/workflows/deployment/mcp) can expose a deployed workflow as a tool. Those options let one graph serve an application backend, a conversational interface, or another AI system without rebuilding its orchestration logic for each surface.
+
+Choose this category when you want faster construction and easier inspection than a code-first framework provides. The main differences concern how deeply each builder supports agent reasoning, how much deterministic control remains available, and how you can deploy the finished workflow. This [OpenAI, n8n, and Sim comparison](https://www.sim.ai/library/openai-vs-n8n-vs-sim) examines those distinctions in more detail.
+
+### Model-vendor-native stacks: OpenAI Agents SDK
+
+Provider-native stacks package agent orchestration around one company's models, APIs, and tool conventions. The [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) combines function tools, built-in tools, agent handoffs, guardrails, sessions, and tracing. You define agent instructions and available tools, while the stack manages model calls and the loop that selects and executes those tools.
+
+OpenAI maintains the models and orchestration interfaces together, so new model capabilities can reach the OpenAI Agents SDK without a separate compatibility layer. The SDK also lets you add application logic around agent runs, including [conditional routing and handoffs](https://openai.github.io/openai-agents-python/handoffs/) between specialized agents.
+
+The main tradeoff concerns model and deployment choice. An application built around OpenAI-specific tools, response objects, and tracing requires extra work to support another provider or a self-hosted model. You still need to host the surrounding application unless a separate OpenAI product supplies the user interface or runtime surface.
+
+You may choose the OpenAI Agents SDK when your application already standardizes on OpenAI models and you want direct access to their tool-calling behavior. A model-neutral framework usually fits better when you expect to switch providers, run local models, or deploy the same workflow across several runtime environments.
+
+## Best AI agent orchestration frameworks in 2026
+
+The table compares seven prominent orchestration options across five decision criteria: builder model, agent depth, deterministic control, deployment surfaces, and self-hosting or license model.
+
+The product capabilities and license classifications below are current as of August 2026. LangGraph and CrewAI use the permissive MIT license; n8n uses its fair-code Sustainable Use License; Sim's core uses Apache 2.0; and the OpenAI Agents SDK is MIT-licensed, while related hosted OpenAI services remain proprietary. Make and Zapier are proprietary cloud products. Review the linked license or terms pages for the current legal text before making a procurement or distribution decision.
+
+| Framework | Builder model | Agent depth | Deterministic control | Deployment surfaces | Self-hosting and license |
+| --- | --- | --- | --- | --- | --- |
+| [LangGraph](https://docs.langchain.com/oss/python/langgraph/graph-api) | ✅ Code-first graph | ✅ Stateful agent runtime | ✅ Nodes, branches, loops | 🟡 App or API | ✅ Self-hosted, [MIT](https://github.com/langchain-ai/langgraph/blob/main/LICENSE) |
+| [CrewAI](https://docs.crewai.com/en/concepts/crews) | ✅ Code-first roles and tasks | ✅ Multi-agent runtime | 🟡 [Flows and task routing](https://docs.crewai.com/en/concepts/flows) | 🟡 App or API | ✅ Self-hosted, [MIT](https://github.com/crewAIInc/crewAI/blob/main/LICENSE) |
+| [n8n](https://docs.n8n.io/advanced-ai/) | ✅ Visual workflow canvas | 🟡 Agents within automation | ✅ [Branches and loops](https://docs.n8n.io/flow-logic/) | ✅ [Webhooks](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/), [API](https://docs.n8n.io/api/), [chat](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-langchain.chattrigger/) | 🟡 Self-hosted, [fair-code Sustainable Use License](https://docs.n8n.io/privacy-and-security/sustainable-use-license) |
+| [Make](https://help.make.com/scenario-editor) | ✅ Visual workflow canvas | 🟡 [AI inside automation](https://help.make.com/make-ai-agents-new) | ✅ [Routes, filters, iterators](https://help.make.com/router) | 🟡 [Webhooks](https://help.make.com/webhooks) and [API](https://developers.make.com/api-documentation) | ❌ [Proprietary cloud](https://www.make.com/en/terms-and-conditions) |
+| [Zapier](https://help.zapier.com/hc/en-us/articles/8496181725453-Create-Zaps) | ✅ Visual and natural language | 🟡 [Agents plus app automation](https://help.zapier.com/hc/en-us/articles/30219476645645-Create-an-agent-in-Zapier-Agents) | 🟡 [Paths](https://help.zapier.com/hc/en-us/articles/8496277737997-Add-branching-logic-to-Zaps-with-paths) and [approval steps](https://zapier.com/apps/approval/integrations) | 🟡 [Apps](https://zapier.com/apps), [agent chat](https://help.zapier.com/hc/en-us/articles/30219476645645-Create-an-agent-in-Zapier-Agents), [webhooks](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zaps) | ❌ [Proprietary cloud](https://zapier.com/tos) |
+| Sim | ✅ Natural language, visual, API | ✅ Agent-native runtime | ✅ Branches, loops, approvals | ✅ [API, hosted chat, MCP](https://docs.sim.ai/workflows/deployment) | ✅ Self-hosted, [Apache 2.0 core](https://github.com/simstudioai/sim) |
+| [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) | ✅ Code-first SDK | ✅ Native agents and handoffs | 🟡 Code-defined routing and guardrails | 🟡 App-managed APIs and interfaces | 🟡 [MIT-licensed SDK](https://github.com/openai/openai-agents-python/blob/main/LICENSE), proprietary services |
+
+## Choosing the right orchestration approach
+
+Code-first frameworks suit you when orchestration behavior must live in your application code. [LangGraph](https://docs.langchain.com/oss/python/langgraph/overview) and [CrewAI](https://docs.crewai.com/) let engineers define state, agent roles, tool calls, and failure handling directly. You gain low-level control, but you must often assemble deployment, interfaces, and monitoring separately.
+
+Visual and natural-language builders suit you when build speed and operational visibility take priority. Platforms such as [n8n](https://docs.n8n.io/), [Make](https://help.make.com/), [Zapier](https://help.zapier.com/hc/en-us), and Sim expose workflow logic on a canvas. Compare their documented agent runtime depth, approval controls, and production surfaces. For example, Sim's [deployment surfaces](https://docs.sim.ai/workflows/deployment) include an API and hosted chat, while its [MCP support](https://docs.sim.ai/workflows/deployment/mcp) can publish a deployed workflow as a tool.
+
+Model-vendor-native stacks suit you when your application already depends on one provider. The [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) closely supports OpenAI models and tool-calling conventions, but changing providers may require more rework.
+
+Licensing can decide the category before features do. Permissive open-source licenses such as [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) provide broad rights to modify and distribute software. Fair-code licenses may restrict commercial use, while proprietary products keep source code and hosting control with the vendor. Check the exact license and enterprise terms if you need self-hosting, internal modifications, or resale rights. For a broader selection, review these [open-source AI agent platforms](https://www.sim.ai/library/open-source-ai-agent-platforms).
+
+## Where Sim fits in this landscape
+
+Sim combines agent reasoning and deterministic control in one visual workflow graph. You can place model decisions beside explicit branches, code, and human approvals, which keeps uncertain tasks within defined operating rules. The same versioned workflow can run through an API or hosted chat. Sim can also [publish it as an MCP tool](https://docs.sim.ai/workflows/deployment/mcp).
+
+Sim's core uses the permissive [Apache 2.0 license](https://github.com/simstudioai/sim), which supports inspection, modification, and self-hosting. Readers evaluating that final deployment option can follow this guide to [turn a workflow into a reusable MCP tool](https://www.sim.ai/library/how-to-turn-a-workflow-into-a-reusable-mcp-tool).
+
+To build your first workflow, follow the [Sim documentation quickstart](https://docs.sim.ai/quickstart).
diff --git a/apps/sim/public/library/ai-agent-orchestration-frameworks-explained/cover.jpg b/apps/sim/public/library/ai-agent-orchestration-frameworks-explained/cover.jpg
new file mode 100644
index 00000000000..8b93e0a39b6
Binary files /dev/null and b/apps/sim/public/library/ai-agent-orchestration-frameworks-explained/cover.jpg differ