Skip to content
Read the docs
Open source and MIT licensed

Agentdock serves a compiled graph as one typed event stream. Pipe it to Node, return a Web Response, or render it with editable React chat components.

Start building
npm i @agentdock-ai/agentdock
AssistantRuns your graphReady

Find this week's release highlights and draft a team update.

Event stream0 events
  1. Waiting for the run to start

The same events reach Node, Web Response, and React clients.

A local simulation. Approve or decline to watch the run resume.

Fits the stack you already use
  • LangGraph
  • TypeScript
  • Node.js
  • React
  • Tailwind CSS

Three layers. One event contract.

Your graph does the thinking. Agentdock carries every step to the client. Your interface decides how it looks.

  1. Step 1

    Your graph

    Models, tools, checkpoints, and interrupts stay in the graph you already wrote.

    LangGraph
  2. Step 2

    One event stream

    Graph output becomes canonical events, with backpressure, cancellation, and cleanup handled.

    Agentdock core
  3. Step 3

    Your interface

    Render with editable React components, or consume the events in any client you build.

    Agentdock UI or yours

Authentication, requests, thread identity, and infrastructure stay with your application.

A small core. An interface you can edit.

Browse UI components
Server

Agentdock core

Serve your compiled graph through a Node response, a Web Response, or an async iterable.

  1. run.started
  2. tool.completed
  3. message.part.delta
  4. interrupt.requiredYour turn
  • Backpressure and disconnect cancellation
  • Native checkpoint reads and resume
  • One shared JSON event contract
Read the API reference
React

Agentdock UI

Copy chat components into your app, then shape every detail with your own theme and primitives.

  • Streaming, Markdown, and tool disclosures
  • Approvals, cancellation, and saved history
  • App-owned adapter and editable source
npx @agentdock-ai/agentdock-ui add chat

A few lines in the route you already have.

No new agent loop to learn. Hand Agentdock your graph inside an authorized route, and the events flow to your app.

  • Keep your framework, model, and tools
  • Abort signals cancel the run cleanly
Walk through the quickstart
controller.ts
import { Agentdock } from "@agentdock-ai/agentdock"; // Use the compiled LangGraph graph you already own.const runtime = new Agentdock(graph); // Your route authenticates and authorizes the request.await runtime.pipe(response, {  threadId: authorizedThreadId,  input: { messages: [{ role: "user", content: prompt }] },  context: trustedContext,});
Compiled graph in, canonical events outSetup guide

Let your coding agent do the setup.

Paste this brief into your coding agent. It reads the Agentdock guide, asks about your app first, and then builds to fit.

Read the agent guide
Agent brief
Read https://agentdock-ai.vercel.app/skills.md and the relevant Agentdock docs. Inspect my app, then ask me these unanswered questions and wait before coding:
- Who will use the agent, and what should it help them do?
- What framework, APIs, authentication, and deployment setup does the app use?
- How should threads and conversation history be identified and stored?
- Which tools or side effects are needed, and what requires approval?
- What UI, file uploads, constraints, and success criteria do I need?
Ask only what the code does not answer. After I respond, implement the smallest suitable solution with LangGraph and Agentdock; use Agentdock UI if a chat interface is needed. Keep secrets, authorization, trusted thread IDs, and persistence app-owned. Use canonical Agentdock events and a stable ChatAdapter. Verify relevant checks and summarize.

Questions before you start.

Anything else is covered in the documentation.

No. Agentdock serves a graph you build with LangGraph or LangChain. Those projects own execution, models, tools, checkpoints, and interrupts. Agentdock maps events and handles streaming transports, backpressure, cancellation, and response cleanup.

Yes. Consume the contract events directly, stream them to your own interface, or use a Node response or Web Response. Agentdock UI is an optional React layer on the same event contract.

The core fits into your existing route controllers. The UI is editable React source designed for TypeScript, Tailwind CSS 4, and shadcn semantic tokens, with Radix or Base UI primitives. Your application supplies its request adapter.

LangGraph checkpoints and native interrupts hold execution state. Agentdock can read messages and pending resume state; your application authorizes every read and continuation. The UI can hydrate history and display pending approvals through its app-owned adapter.

Yes. From your React app, run npx @agentdock-ai/agentdock-ui add chat. The installer copies editable chat components into your app and installs any missing dependencies.

Ship the agent. Keep the product yours.

Start with your graph. Agentdock connects the rest.

Start building View on GitHub