Threadplane · MIT framework

Ship production agent UIs in Angular.

Build fullstack agentic apps in Angular with: durable threads, interrupts, subagents, planning, memory, and generative UI using Vercel json-render and Google A2UI.

Talk to our engineers

LangGraph + AG-UI Durable threads Interrupts Subagents Planning + memory json-render + A2UI

Not another backend agent runtime. Keep LangGraph, Genkit, Mastra, CrewAI, or your own service. Threadplane solves the Angular UI layer.

demo.threadplane.ai

Canonical demo — agent renders a live airline operations dashboard with KPI cards, charts, and a disruptions table

Open in cockpit →

Works with your agent stack

Bring the model, runtime, and UI protocol you already use.

Threadplane gives Angular teams production-ready chat, durable threads, interrupts, subagents, planning, memory, and generative UI without locking the backend to one provider.

Model providers

OpenAI

model provider

Anthropic

model provider

Google Gemini

model provider

Azure OpenAI

cloud provider

Amazon Bedrock

cloud provider

Agent runtimes

LangGraph

native adapter

AG-UI

protocol adapter

CrewAI

via AG-UI

Mastra

via AG-UI

Pydantic AI

via AG-UI

Microsoft Agent Framework

via AG-UI

AWS Strands

via AG-UI

CopilotKit Runtime

via AG-UI

Angular surface

Angular

native DI + signals

RxJS

interop ready

Vercel json-render

render protocol

Google A2UI

render protocol

Why this exists

Everything an Angular agent needs once the demo works.

A streaming chat tutorial takes an hour. Shipping a real agent — durable, interruptible, observable, on your design system — takes most teams six months. Threadplane gives the Angular surface that the rest of the stack assumes you've already built.

Durable threadsPersist across reloads, resume, branch, replay.
threadId signal + durable transports
Resumable interruptsHuman-in-the-loop pause, resume token, retry, cancel.
interrupt(), resume()
Tool calls as eventsStream progress, structured args, surfaced errors.
tool events on injectAgent()
Streaming state as signalsmessages(), status(), error() — not promises.
signal-native injectAgent()
Generative UI on your design systemVercel json-render + Google A2UI rendered into your Angular components.
@threadplane/render
Recoverable errorsRetry, reload, error boundaries, fallback content.
error(), reload()
Backend portabilityLangGraph today; AG-UI / Mastra / CrewAI / your own tomorrow — same UI.
runtime adapters behind one contract
Angular-nativeDI, signals, RxJS interop — no React rewrite.
built on Angular primitives, not ported
Observability hooksTracing seams; app telemetry off by default.
event hooks, opt-in only
MIT + self-hostedOwn the primitives long-term, no vendor lock-in.
MIT-licensed, no runtime SaaS dependency

Want help walking these on your codebase? Pilot to Prod →

Stream

Build the Angular UI layer for production agents.

provideAgent + agent() give you headless chat, durable threads, interrupts, tool progress, and generative UI. LangGraph and AG-UI adapters share the contract, so teams can swap runtimes without rewriting the Angular surface.

Headless chat and durable thread state
Interrupts, tool progress, branch/history
Adapters: LangGraph (@threadplane/langgraph), AG-UI (@threadplane/ag-ui)
One Angular UI layer, swappable runtimes

provideAgent

Wire the agent into your app.config.ts.

AgUiAdapter

Any AG-UI compliant backend.

LangGraphAdapter

Native LangGraph streaming.

Read the streaming guide →

cockpit.threadplane.ai/langgraph/core-capabilities/streaming/overview/python

Cockpit reference app — Angular streaming guide with provideAgent setup

Render

Generative UI that renders into your design system.

Server-emitted JSON specs become Angular components you already own. Vercel json-render and Google A2UI both supported, with per-component fallback and a readiness gate.

Per-component fallback API + readiness gate
A2UI v0.9-compatible protocol + Vercel json-render adapter
Renders into your existing component library
Server-side schema, client-side trust

chat-timeline

Drop-in conversation surface.

chat-debug

Live devtools for tool calls.

GenUI surfaces

Schema-driven UI from agent output.

See @threadplane/render →

cockpit.threadplane.ai

Cockpit reference app — API reference rendered as structured cards

Ship

Patterns built for production, not demos.

Error boundaries, observability hooks, fallback strategies — the stuff that turns a demo into a real app. MIT-licensed, so the code is yours forever.

error() / status() / reload() signals
Readiness gate + per-component fallback
Thread persistence patterns
MIT licensed — own it forever

error/status/reload

Boundary signals for every agent.

readiness gate

Hold renders until the surface is real.

thread persistence

Restore conversations across sessions.

Production patterns →

demo.threadplane.ai

Loading demo…

For teams

Ship your first Angular agent in 8 weeks.

Pilot-to-Prod is a concierge delivery — concrete outcomes, your engineers in the driver's seat, no lock-in.

Working agent demo on your domain
Hardened production patterns (error/fallback/observability)
Deploy-ready integration with your CI/CD
Team trained on the framework + LangGraph

See the program Book a call

1

Discover

Map your stack, surfaces, and the agentic work that earns its keep.

2

Build

Ship a working demo on your real data, in your real Angular app.

3

Harden

Observability, error boundaries, deploy paths, on-call patterns.

4

Train

Your team owns the stack. We leave you with a runbook, not a black box.

Field report

The last-mile gap in Angular AI.

Six production-readiness dimensions for Angular AI
Concrete patterns — error boundaries, fallbacks, observability, deploy
No vendor pitch. Just what we learned shipping it.

Already on the list? Download the PDF directly.

angular-agent-readiness-guide.pdf

Field report · 18 pages

From Prototype to Production

Six production-readiness dimensions for Angular AI teams.

Threadplane

Built on principles

What we won't do.

Honest commitments, not aspirations.

No closed core

MIT today, MIT tomorrow. Primitives and compositions both stay in the open repo. Pilot-to-Prod is the only paid thing.

No abandoned majors

We support Angular’s current and previous LTS versions.

No required cloud

Self-host LangGraph + your Angular app. Run it all in your VPC.

No app telemetry

We don’t collect prompts, completions, tool data, or app runtime content by default. Package installs send a minimal opt-out ping.

No model lock-in

Adapters work with any LLM your runtime supports. Swap providers without changing Angular code.

Questions

Frequently asked questions.

How is this different from CopilotKit or AG-UI directly?

CopilotKit has an Angular SDK, and AG-UI is a protocol rather than a complete Angular UI layer. Threadplane gives Angular teams the production surface around those runtimes: headless chat, durable threads, interrupts, subagents, planning, memory, generative UI, and adapters for LangGraph and AG-UI-compatible backends.

Does it work with my existing Angular app?

Yes. Drop provideAgent (from @threadplane/langgraph or @threadplane/ag-ui) into your app.config.ts. The headless primitives don’t impose any UI; the chat compositions are opt-in.

Can I use this without LangGraph?

Yes. Use the @threadplane/ag-ui adapter for any AG-UI compliant backend, or implement the agent contract yourself. Threadplane keeps the Angular UI layer stable while the backend agent runtime can change.

Which adapter should I use — @threadplane/langgraph or @threadplane/ag-ui?

If your backend is LangGraph Platform, use @threadplane/langgraph. If your backend speaks the AG-UI protocol (CrewAI, Mastra, Microsoft Agent Framework, AG2, Pydantic AI, AWS Strands, CopilotKit runtime), use @threadplane/ag-ui. Both expose the same provideAgent/injectAgent API — see /docs/choosing-an-adapter for a side-by-side comparison.

Is the Pilot-to-Prod program required?

No. The libraries are MIT-licensed and complete on their own. Pilot-to-Prod is for teams who want concierge delivery, not a paywall.

What does it cost?

Libraries: free, MIT. Pilot-to-Prod: scoped per engagement — see the pricing page.

Is this production-ready today?

It runs the full stack in our reference deployment (cockpit.threadplane.ai), and breaking changes are called out in release notes. We support Angular’s current and previous LTS versions.

Where do I report issues?

GitHub Issues. Pilot customers also get a private channel.

I’m using CopilotKit today — how hard is the migration?

Component-by-component. CopilotKit’s chat hooks have rough equivalents in our injectAgent() signal API, and CopilotKit actions map to LangGraph/AG-UI tool calls. Thread state lives in a service (not the component tree), so plan a session to port that. There isn’t a one-shot codemod.

Does it work with Angular Universal / SSR?

Streaming is client-side by design — agents are stateful and signal-based. If your shell is SSR’d, the agent-talking parts stay client-only; render fallbacks during hydration via standard Angular SSR patterns.

How do I test agent-driven components?

The agent is provided through Angular DI, so test doubles work the way you’re used to — supply a stub agent in your test module, drive it with signals, assert on the rendered output. See /docs/langgraph/guides/testing.

Stop stalling on agentic Angular.

Install the framework, read the docs, and have a streaming chat in your app this afternoon.

Try the demo →See each feature in action →

MIT · No signup required · App telemetry off by default

Blog