Inside the Open Agent Platform By LangChain: Build Smart Agents, Not More Backend

The new agent framework by LangChain. This guide walks developers and AI leaders through deploying LangGraph agents, integrating RAG, and orchestrating multi-agent workflows. Real code. Real use cases. Zero hype.

Open Agent Platform (OAP) is a no-code, web-based interface for creating, managing, and orchestrating LangGraph agents—ideal for both developers and AI leaders who want the power of LangChain without hand-rolling every line of code. In this guide, you’ll learn:

  • What OAP is and its core features, from RAG integration to multi-agent supervision GitHub.
  • How to get started: deploying pre-built agents, setting up auth, RAG, and MCP servers Open Agent Platform.
  • Building custom agents, wiring in tools, and tweaking configurations for your use case GitHub.
  • Advanced orchestration: using the Supervisor agent for multi-agent workflows Open Agent Platform.
  • A side-by-side comparison with Flowise and other platforms, so you can pick the right tool for your team flowiseai.comDowneLink.

Below is a friendly, code-filled tour—no hype, just clear steps and practical examples.

What Is Open Agent Platform?

Open Agent Platform is a modern, browser-based UI for LangGraph agents, letting teams spin up assistants, connect to tools, and supervise agent-to-agent workflows without writing a backend from scratch GitHub. It supports:

  • Agent Management: Create, configure, and chat with agents via a rich interface.
  • RAG Integration: Out-of-the-box support for retrieval-augmented generation through LangConnect GitHub.
  • MCP Tools: Hook agents into external services (e.g., search, databases) using any Streamable HTTP MCP server GitHub.
  • Multi-Agent Supervision: Orchestrate complex workflows by having one agent supervise others GitHub.
  • Authentication & Access Control: Built-in Supabase auth, easily swapped out for your own provider GitHub.

Getting Started

1. Deploy Pre-Built Agents

Clone and deploy the two sample agents to your LangGraph account:

git clone https://github.com/langchain-ai/open-agent-platform-tools-agent.git
cd open-agent-platform-tools-agent
# Follow the README in that repo
git clone https://github.com/langchain-ai/open-agent-platform-supervisor-agent.git
cd open-agent-platform-supervisor-agent
# Follow the README in that repo

These agents (Tools Agent and Supervisor Agent) come pre-wired to demonstrate tool usage and orchestration Open Agent Platform.

2. Configure Environment Variables

Collect each deployment’s IDs and URLs from the LangGraph /info endpoint, then set:

export NEXT_PUBLIC_DEPLOYMENTS='[
  {
    "id":"bf63dc89-1de7-4a65-8336-af9ecda479d6",
    "tenantId":"42d732b3-1324-4226-9fe9-513044dceb58",
    "deploymentUrl":"http://localhost:2024",
    "name":"Local deployment",
    "isDefault":true,
    "defaultGraphId":"agent"
  }
]'

3. Authentication Setup

By default, OAP uses Supabase:

export NEXT_PUBLIC_SUPABASE_URL="https://xyz.supabase.co"
export NEXT_PUBLIC_SUPABASE_ANON_KEY="public-anon-key"

Enable Google (or your preferred) auth in your Supabase console, or swap out the client code Open Agent Platform.

4. RAG & MCP Servers

  • RAG (LangConnect): Deploy LangConnect and set
export NEXT_PUBLIC_RAG_API_URL="http://localhost:8080"
  • MCP: Point to your MCP server‍
export NEXT_PUBLIC_MCP_SERVER_URL="https://mcp.myorg.com"
export NEXT_PUBLIC_MCP_AUTH_REQUIRED=true # if needed
``` :contentReference[oaicite:12]{index=12}.

5. Launch the App

cd apps/web
yarn install
yarn dev

Visit http://localhost:3000 and you’re live!

Building and Configuring Custom Agents

OAP treats each agent as a config over a LangGraph graph. You define:

  • Model & System Prompt
  • Tools List (via MCP servers)
  • Memory Config
  • Custom UI Fields (via x_oap_ui_config metadata on Zod schemas) GitHub.

Example agent config snippet:

{
  "name": "PDF QA Bot",
  "description": "Answer questions from PDF docs",
  "model": "gpt-4",
  "tools": [
    {
      "id": "pdf-reader-tool-uuid",
      "name": "PDF Reader",
      "description": "Extracts text from PDFs",
      "url": "https://my-mcp.com/pdf",
      "schema": "{ /* JSON Schema for inputs */ }"
    }
  ],
  "memory": {
    "type": "conversation",
    "returnMessages": true
  }
}

Once that JSON is deployed on LangGraph and added to your NEXT_PUBLIC_DEPLOYMENTS, OAP will render the fields and let users chat with that agent.

Orchestrating with the Supervisor Agent

The Supervisor Agent coordinates multiple child agents. You might have one handle data ingestion, another fine-tune analysis, and a third summarize results—Supervisor ensures they chat in sequence and handles failures gracefully.

const supervisor = await SupervisorAgent.create({
  llm: chatModel,
  agents: [toolsAgent, pdfQABot],
  orchestrationPlan: [
    { agent: "toolsAgent", task: "fetchURLs" },
    { agent: "pdfQABot", task: "answerQuestions" }
  ]
});

This multi-agent choreography is plugged into OAP’s Supervisor UI panel for monitoring Open Agent Platform.

Advanced Integrations

RAG with LangConnect

Configure vector stores, embeddings, and query pipelines using LangConnect’s API. OAP will surface search interfaces right in your agent chat.

Custom Auth Providers

Swap out Supabase by replacing the auth client in apps/web—we’ve abstracted auth hooks so you can inject Auth0, Firebase, or a homegrown solution GitHub.

Comparing OAP with Flowise and Others

Feature Open Agent Platform Flowise SuperAgent / Eidolon
Interface Web UI over LangGraph, config-driven Drag-and-drop canvas (React Flow) Code-first SDK (Python/TS)
Customization Full JSON-schema control + code hooks Node templates + custom JS snippets Extend via code; no UI out-of-box
Deployment Host anywhere; env var config Local or Docker; no cloud deployer Integrate into apps via SDK
Multi-Agent Built-in Supervisor Agent Limited; manual chaining via nodes Built-in in some SDKs
RAG Support LangConnect native Uses LangChain connectors Custom coding required
  • Flowise offers a drag-and-drop visual builder atop LangChain, great for rapid prototyping and non-devs, but lacks built-in multi-agent orchestration and easy cloud deployment flowiseai.comDowneLink.
  • Eidolon/SuperAgent (e.g., SuperAgent, Eidolon) are code-first SDKs providing maximal flexibility but require writing orchestration logic by hand Metaschool.

Example Use Case: PDF QA Workflow

  1. Ingest PDFs with a File Upload tool.
  2. Extract Text via an MCP PDF Reader.
  3. Vectorize & Store in a Pinecone/RAG connector.
  4. Query via Retrieval + GPT.

OAP’s UI walks you through tool selection and prompt templating, then you chat like:

You: “What does section 3.2 say about performance benchmarks?”
Agent: “It describes that the system achieves 95% accuracy under load…”

All without a single line of backend glue code GitHub.

Best Practices

  • Version your agent configs in Git for auditability.
  • Use supervisor plans to handle retries and fallbacks.
  • Lock down RAG servers behind auth for sensitive data.
  • Leverage x_oap_ui_config in Zod for rich, type-safe UI fields.

With OAP, you get the best of both worlds: a no-code, GUI-driven experience for common patterns, yet complete extensibility through LangChain and LangGraph under the hood. Whether you’re an AI VP mapping out your team’s tooling strategy or a developer tired of boilerplate, OAP scales with your needs.

Until the next one,

‍

Cohorte Team

May 15, 2025