Visual LangGraph IDE

Build agent workflows
without leaving the canvas

LangStitch is a drag-and-drop IDE for LangGraph — design graphs, configure skills, guardrails, RAG pipelines, and export a Python 3.13 multi-module project in one click.

Download LangTailor Install VSX GitHub
LangGraph Python 3.13 Component SDK RAG LangSmith MCP Studio Marketplace LangTailor desktop

Get started

Install the canvas extension or LangTailor desktop

LangStitch ships as a downloadable VS Code extension (`.vsix`) and as LangTailor — a portable desktop IDE. There is no hosted browser IDE.

Download & install Read docs
  • VSX / Open VSX — codium --install-extension langstitch.langtailor-canvas
  • LangTailor — portable Windows / macOS from GitHub Releases
  • Local dev — npm install && npm start (contributors)

Platform API (Docker)

docker run -p 8787:8787 \
  ghcr.io/langstitch/langstitch-api:latest

→ http://localhost:8787

LangTailor desktop

# install the extension from Open VSX
codium --install-extension langstitch.langtailor-canvas

→ Download LangTailor

Everything you need to ship agents

◇

Visual canvas

LLM, Tool, Agent, RAG, Multi-Intent Classifier, Decision, Subgraph, Function nodes — color-coded and draggable.

🧩

SDK Component Designer

Build your own nodes, connectors & adaptors visually — ports, typed config, theme, and a safe Python codegen template. No source edits, exportable as .component.json.

✦

Asset designers

Skill, Guardrail, Business Rules, Persona, and RAG pipeline designers — chunking, embedding, vector / vectorless / hybrid.

⚡

Python 3.13 export

Multi-module ZIP: graphs, nodes, skills, prompts, tools, guardrails, rag — plus langsmith.json for IDE re-import.

🔗

Integrations

MCP Studio, tool & agent registry, remote graphs, A2A, LangSmith, Langfuse, structured logging.

🚀

Platform

Git sync, versioning, Docker build, Helm deploy — full stack via FastAPI backend.

🛒

Plugin marketplace

Publish and install community components, connectors, and LangTailor plugins — with review flow, at marketplace.langstitch.com.

🖥️

LangTailor desktop

The downloadable LangGraph IDE — a branded VS Code / Code-OSS build with the canvas, Python export, and marketplace sync built in. Get LangTailor →

✓

CI & quality

Playwright E2E tests, agent smoke tests, VSIX packaging, Open VSX publish, Docker API images, and releases.

Component SDK & multi-language SDK

Bring LangStitch to your stack

Extend LangStitch two ways. Use the SDK Component Designer to author custom nodes, connectors, and adaptors visually — then export them as portable components. Or use the code SDK to build the same graphs, skills, guardrails, and policies with decorators, YAML/JSON config, and a CLI scaffold. Python ships today; Spring, Rust, and Go are on the way.

SDK Component Designer

New

A visual designer for community-extensible components. Define a component once — ports, a typed config-field schema, theme, and a Python codegen template — and it appears in the palette like any built-in node. No source edits, no rebuild. Components are portable as .component.json and shareable through the marketplace.

Author visually

Open the Components tab, add ports and config fields (string, number, boolean, select, code, secret, JSON), pick a theme, and write a codegen template with a live Python preview.

Place & configure

Drag your component from the Custom Components palette group onto the canvas. Selecting it shows an auto-generated property form driven by your config schema.

Safe Python export

# A custom "HTTP Fetch" component renders into the graph:
def http_1(state: State) -> dict:
    """Fetch Page — Fetch a URL and store the body"""
    import httpx
    url = "https://api.example.com/data"
    api_key = os.environ.get("MY_SECRET_ENV")   # secrets never inlined
    resp = httpx.request("POST", url, timeout=12, verify=False)
    return {"page": resp.text}

Templating is pure, whitelisted substitution — no eval, no arbitrary execution. Secret fields emit os.environ.get(...); values are escaped per field kind.

custom nodes connectors adaptors typed config fields safe codegen template secrets → os.environ.get .component.json palette + auto forms marketplace-ready
Get the canvas extension Browse the marketplace
Python Available

Decorators, config, providers, MCP, and a scaffolding CLI. Python 3.10+.

Spring (Java) Coming soon

Spring Boot starters and annotations for LangStitch graphs and gateways.

Rust Coming soon

A typed, async-first crate for high-performance agent runtimes.

Go Coming soon

Idiomatic Go module for building and serving LangStitch graphs.

Python SDK

v0.1.0

Install the SDK, scaffold a project, and describe your agent with decorators. Configuration comes from application.yaml (or a precompiled application.json) and env.yaml.

Install

pip install langstitch-sdk
# with extras:
pip install "langstitch-sdk[server,graph,llm,http]"

Scaffold a project

langstitch new my-agent
cd my-agent
pip install -e .
python -m app        # bootstrap + print app info
langstitch run       # start the API server

Generates dedicated packages for graphs, nodes, skills, guardrails, policies, personas, tools, and agents.

Describe your agent with decorators

from langstitch import (
    graph, graph_node, skill, persona,
    input_guardrail, output_guardrail, business_policy,
    tool, worker_agent, configuration,
    langstitch_graph_server, langstitch_mcp_server,
)

@persona(role="assistant", tone="helpful, concise")
def assistant() -> str:
    return "You are a helpful LangStitch assistant."

@tool(tags=["math"], roles=["user"])
def add(a: float, b: float) -> float:
    return a + b

@graph_node(description="Answer the latest message.")
def respond(state: dict) -> dict:
    ...

@langstitch_graph_server(name="my-agent", protocol="http", port=8000)
class Server:
    """Graph API server."""
@graph / @graph_node @skill / @persona @input_guardrail / @output_guardrail @business_policy @tool / @worker_agent @configuration @langstitch_graph_server @langstitch_mcp_server get_llm_provider() get_http_client("service") hierarchical context dynamic tool / agent registries
SDK on PyPI Read the SDK docs

Market landscape

How LangStitch compares

LangStitch takes the best ideas from visual agent builders and LangGraph tooling — then centers production support and developer experience. Ship real Python projects, not throwaway JSON blobs.

What most tools optimize for

LangGraph Studio & LangSmith

  • Excellent tracing, evals, and LangGraph-native debugging
  • Cloud-first — assumes LangSmith account and hosted runtime
  • Limited first-class designers for guardrails, business rules, and personas
  • Export is code-oriented; less opinionated multi-module project layout

Langflow & Flowise

  • Fast visual prototyping with broad component libraries
  • Flow JSON is the source of truth — harder to version in Git like app code
  • RAG is often node-level, not a full pipeline designer with hybrid retrieval
  • Production deploy, Helm, and platform API are not the primary UX

Dify, n8n & low-code platforms

  • Strong no-code workflows and connector marketplaces
  • LangGraph semantics and checkpointing are secondary or absent
  • Vendor-hosted runtime — less control over K8s layout and export structure
  • Agent governance (RBAC tools, guardrails as assets) is lighter

Hand-rolled LangGraph repos

  • Full control — but every team reinvents graph layout, RAG wiring, and export scripts
  • Design and code drift apart; onboarding new devs is slow
  • No visual map of skills, guardrails, and personas alongside the graph
  • CI and deploy pipelines are bespoke per project

Side-by-side

Capability LangStitch LangGraph Studio Langflow / Flowise Dify / n8n
Visual LangGraph canvas ✓ Native ✓ Native Partial / adapter ✗ Own runtime
Downloadable VSX / desktop IDE ✓ Open VSX + LangTailor Cloud account Self-host or cloud Cloud or self-host
Asset designers (skills, guardrails, rules, personas) ✓ First-class sidebar Limited Prompt / component level App / workflow level
RAG pipeline designer (vector / vectorless / hybrid) ✓ Dedicated designer + node Via code / templates Node chains Knowledge base UI
Multi-intent routing node ✓ Built-in classifier node Manual graph edges Router components Branching workflows
Python multi-module export (Git-friendly) ✓ Python 3.13 ZIP + langsmith.json Code export JSON / Python varies API / limited export
Git sync & versioning in IDE ✓ Platform API LangSmith projects ✗ Manual Platform history
Docker build & Helm deploy from UI ✓ Platform panel ✗ ✗ Managed hosting
MCP Studio & tool registry ✓ Built-in MCP via ecosystem Plugins Integrations catalog
Visual custom-component SDK (nodes / connectors / adaptors) ✓ Component Designer + safe codegen Code only Custom components in code Connector SDK
LangSmith / Langfuse observability ✓ Export + hooks ✓ Deep native Plugins Built-in logs
Open source & self-hostable ✓ MIT Partial / cloud ✓ OSS Freemium / OSS tiers
Managed multi-tenant SaaS → Roadmap ✓ LangSmith Cloud ✓ Cloud tiers ✓ Core product
Real-time collaborative editing → Planned ✓ Team features Rare ✓ Shared workspaces
Eval datasets & trace replay (LangSmith depth) ✓ Platform Eval tab + export ✓ Best-in-class Basic Moderate
Enterprise SSO / org RBAC → Platform RBAC first ✓ Enterprise Varies ✓ Enterprise tiers
Connector / template marketplace ✓ Built-in marketplace + publish/review LangChain hub ✓ Large libraries ✓ Very large

LangStitch edge — production & DX

  1. Code is the contract — Export a buildable Python 3.13 project with graphs/, skills/, guardrails/, and langsmith.json for round-trip IDE import. Review in PRs like any backend service.
  2. Governance as assets — Skills, guardrails, business rules, and personas are designed once, versioned, and wired on the canvas — not buried in prompt strings.
  3. RAG you can operate — Chunking, embedding, vector / vectorless / hybrid retrieval in a pipeline designer — bound to a RAG Agent node, not a one-off chain.
  4. Platform panel for ops — Git sync, Docker build, Helm deploy, and structured logging hooks — the path from canvas to cluster without a separate toolchain.
  5. Extensible by the community — The SDK Component Designer turns custom nodes, connectors, and adaptors into safe, portable .component.json manifests — shared through a built-in marketplace, not locked to vendor plugins.
  6. Developer-first defaults — Downloadable VSX, LangTailor portable builds, Docker one-liner, Playwright E2E, agent smoke tests, and MIT license — optimized for teams who own their runtime.

Honest gaps — building toward parity + more

  • Managed cloud — No one-click multi-tenant SaaS yet; self-host and Docker first.
  • Deep evals — LangSmith-native dataset runs and trace replay are export hooks today, not full in-IDE eval suites.
  • Live collaboration — Single-editor canvas; no real-time multi-user cursors yet.
  • Enterprise identity — Tool RBAC and guardrails exist; org-wide SSO/SAML is on the roadmap.
  • Marketplace scale — The marketplace and Component Designer are live, but the pre-built catalog is still growing vs mature low-code libraries.

Goal: match the table stakes everyone expects, then win on export quality, governance assets, K8s-native deploy, and the Agent Engineering discipline — not on being another locked SaaS canvas.

Summary: LangStitch is for teams shipping LangGraph to production — visual design when you need speed, real Python when you need control. Use LangSmith for traces; use LangStitch to design, export, and deploy the graph your SREs can support.