Introduction

Building AI agents often requires a complex patchwork of scripts, prompt engineering, and manual backend orchestration. For many developers and AI leaders, the barrier to entry is the sheer amount of “glue code” needed to move from a prototype to a functional assistant. Open Agent Platform is an open-source, no-code agent building platform that removes this friction, allowing users to create, manage, and deploy intelligent agents without writing a single line of backend code. By providing a visual interface for LangGraph agents, it transforms the way teams prototype and scale AI workflows.

What Is Open Agent Platform?

Open Agent Platform (OAP) is a no-code, web-based interface for creating, managing, and orchestrating LangGraph agents for developers and AI leaders who want the power of LangChain without hand-rolling every line of code. It serves as a modern, browser-based UI that allows teams to spin up assistants, connect them to tools, and supervise agent-to-agent workflows without building a backend from scratch.

Maintained by the LangChain team, the project is licensed under the MIT License, ensuring it remains open and extensible. It is designed to target non-developers (citizen developers) while remaining extensible for engineers who may need to drop into code for advanced customizations.

Why Open Agent Platform Matters

Traditionally, building a reliable AI agent requires deep expertise in orchestration frameworks like LangGraph. While powerful, these frameworks often have a steep learning curve and require significant boilerplate to handle state management, persistence, and tool integration. Open Agent Platform fills this gap by providing a visual layer over these complex operations.

The platform’s significance lies in its ability to democratize agent creation. By allowing business analysts, product managers, and AI leaders to prototype agents in minutes, it accelerates the development cycle. Instead of waiting for an engineering sprint to test a new prompt or tool, teams can iterate in real-time within the OAP dashboard.

Furthermore, OAP integrates seamlessly with the broader LangChain ecosystem, meaning that agents created here can leverage the thousands of integrations available to LangChain, future-proofing the AI stack against vendor lock-in.

Key Features

• No-Code Agent Management: Create, configure, and chat with agents via a rich, intuitive web interface, eliminating the need for custom backend development.
• RAG Integration: Out-of-the-box support for Retrieval-Augmented Generation (RAG) through LangConnect, allowing agents to access private data sources and documents.
• MCP Tool Support: Hook agents into external services such as search engines, databases, and internal APIs using any Streamable HTTP Model Context Protocol (MCP) server.
• Multi-Agent Supervision: Orchestrate complex workflows by using a Supervisor agent that can delegate tasks to other specialized agents.
• Built-in Authentication: Includes integrated Supabase authentication and access control, which can be easily swapped for other identity providers.
• LangGraph Runtime: Every agent is a configuration layered on a LangGraph graph, providing built-in persistence, rewind, and rewind, and checkpointing capabilities.
• LangSmith Integration: Seamlessly connect to LangSmith for observability, debugging, and evaluation of agent decisions in real-time.

How Open Agent Platform Compares

When evaluating OAP, it is often compared to other visual AI builders like Dify or Flowise. While those platforms provide excellent drag-and-drop interfaces, OAP’s primary differentiator is its deep, native integration with the LangGraph runtime. This means that any agent built in OAP is fundamentally a LangGraph agent, ensuring that the complex state management and durable execution required for production-grade agents are handled natively.

For teams already invested in the LangChain ecosystem, OAP is the logical choice because it eliminates the need to migrate agents to a different runtime. For those seeking a purely visual experience with a massive library of pre-built enterprise plugins, Dify may be a better fit. However, for those who want the precision and control of LangGraph without the initial coding overhead, OAP provides the most direct path.

Getting Started: Installation

Open Agent Platform can be deployed as a self-hosted instance or used via the hosted version. To self-host, you will need a Supabase account for authentication and database management.

Self-Hosted Deployment

Clone the repository and install the dependencies:

git clone https://github.com/langchain-ai/open-agent-platform.git
cd open-agent-platform
npm install

Environment Configuration

You must configure your environment variables to connect to your LLM provider and authentication service. Create a .env file in the root directory:

SUPABASE_URL=your_supabase_url
SUPABASE_ANON_KEY=your_supabase_anon_key
LANGCHAIN_API_KEY=your_langchain_api_key
OPENAI_API_KEY=your_openai_api_key

Verification

Start the application to verify the installation:

npm run dev

How to Use Open Agent Platform

Once the platform is running, the primary workflow involves creating an agent and connecting it to the necessary tools and data sources.

First, navigate to the Agent Management dashboard. Click “Create New Agent” and provide a name and a system prompt. The system prompt defines the agent’s persona, goals, and the rules it must follow. This is where you define whether the agent is a research assistant, a customer support bot, or a a technical writer.

Next, connect your agent to Tools. In the OAP interface, you can add MCP servers. By providing the URL of an MCP server, the agent instantly gains the capabilities of that server (e.g., the ability to search the web or query a database). This happens without writing any tool-calling logic in code.

Finally, test your agent in the integrated Chat Interface. You can send messages and observe the agent’s reasoning process. If the agent fails to perform a task, you can refine the system prompt or add more tools to improve its performance.

Code Examples

While OAP is no-code, it is built on LangGraph. For power users who wish to extend the platform or understand the underlying architecture, the following examples demonstrate how OAP configurations are mapped to LangGraph logic.

The following example shows how a basic agent configuration in OAP is represented as a a LangGraph graph in the backend:

# Example of the underlying LangGraph logic used by OAP
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END

# Define the state
class AgentState(TypedDict)
    messages: Annotated[list, add_messages]

# Define the graph
workflow = StateGraph(AgentState)

# Add nodes for the LLM and tool execution
workflow.add_node("agent", lambda state: model.invoke(state["messages"]))
workflow.add_node("tools", lambda state: tool_executor.invoke(state["messages"]))

# Define edges
workflow.set_entry_point("agent")
workflow.add_edge("tools", "agent")
workflow.add_conditional_edges("agent", should_continue)

# Compile the graph
app = workflow.compile()

This code snippet illustrates the core loop of an OAP agent: the model reasons, calls a tool if needed, and the graph ensures the agent returns to the the model for final reasoning after the tool output is provided.

Real-World Use Cases

Open Agent Platform is particularly effective for scenarios where rapid prototyping of complex agentic workflows is required without a dedicated backend team.

• Financial Document Analysis: A business analyst can create an agent that uses RAG to query a set of financial reports and summarize them into a table. By connecting the agent to a RAG server via LangConnect, the analyst can upload documents and have the agent perform analysis without writing code.
• Technical Support Automation: A support lead can build an agent that connects to a company’s internal API via an MCP server to check order status and process refunds. The support lead can define the system prompt to ensure the agent follows company policy and handles customer queries professionally.
• Multi-Agent Research Teams: An AI leader can orchestrate a research team where one “Supervisor” agent manages a specialized “Web Search” agent and a “Writer” agent. The using the Supervisor agent pattern, the Supervisor decides which agent to handle the specific part of the research task and delegates the laor.

Contributing to Open Agent Platform

The project is open-source and encourages contributions from the community. Since it is a part of the LangChain ecosystem, it follows standard GitHub flow for contributions.

To contribute, first browse the Issues tab on GitHub to find “good first issues” or suggest new features. If you are looking to develop new tools, you can create MCP servers that can be integrated into OAP. Since the platform is built with modern web technologies, contributions to the UI/UX of the dashboard are also highly valued.

The project maintains a Code of Conduct to ensure a collaborative and respectful environment. All pull requests should be accompanied by a detailed description of the project changes and a detailed description of the project changes.

Community and Support

Open Agent Platform is supported by the LangChain community. Users can find official documentation at docs.oap.langchain.com and explore the platform’s hosted version at oap.langchain.com.

For technical support and discussions, the primary channel is the GitHub Discussions page of the repository. GitHub Issues are used for bug reports and feature requests. The broader LangChain Discord server is also a highly active community where developers can build and share their agent configurations.

Conclusion

Open Agent Platform provides a critical bridge between the power of LangGraph and the accessibility of no-code tools. For teams that want to deploy reliable, stateful AI agents without the burden of backend orchestration, OAP is the laoding solution. It is the right choice when you need to rapidly prototype and iterate on agent personas and tool integrations without sacrificing the production-grade runtime of LangGraph.

While OAP is a great starting point, it is not a replacement for custom code when you need highly specific, edge-case logic that exceeds the current no-code capabilities of the dashboard. However, for the vast majority of agentic workflows, the visual interface significantly reduces the time to value.

Star the repo, try the quickstart, and join the community to start building your first no-code agent today.

Resources

• Open Agent Platform GitHub Repository
• Official OAP Documentation
• Open Agent Platform Hosted App
• LangGraph GitHub Repository