FAQ
The questions developers ask before adopting Dawn. Short, opinionated answers — verdict first, one piece of context, link to the deep page when there is one. This is not a troubleshooting guide and not a roadmap.
Adopting Dawn
Do I have to use LangGraph?
Yes. Dawn is a meta-framework for LangGraph the way Next.js is a meta-framework for React. LangGraph runs the graph; Dawn writes the conventions around it — file-system routing, type inference, the dev server, the build step. If you do not want LangGraph, Dawn is the wrong tool. See Mental Model.
Can I bring my own model provider?
Yes. The built-in agent() route materializes to a LangChain chat model. Dawn infers providers for known model families and lazy-loads the matching LangChain integration package. Set provider explicitly to one of the supported built-in provider ids for aliases, ambiguous model names, local models, or provider-router model ids. Raw graph and chain routes can still instantiate any provider directly. See API Reference.
How does Dawn compare to Mastra / CopilotKit / Vercel AI SDK?
They solve different problems.
- Vercel AI SDK is a client-and-server toolkit for chat UIs and provider-agnostic LLM calls. Dawn does not compete with it — it sits one layer up, organizing whole agent projects, and you can use the AI SDK inside a Dawn route.
- CopilotKit is a frontend-first framework for embedding copilots in existing apps. Dawn is backend-first; the deliverable is a deployable agent runtime, not in-app UI. They compose through Dawn's AG-UI endpoint: both
dawn devanddawn startservePOST /agui/{routeId}with the same route-execution middleware behavior, and the chat example wires a CopilotKitHttpAgentto it. - Mastra is a general-purpose agent framework with its own runtime and abstractions. Dawn is narrower: it does not replace LangGraph, it deletes the boilerplate around it.
If you are already on LangGraph, Dawn fits. If you are not, pick the framework whose runtime you want to live in.
Does Dawn support Python?
No. Dawn is TypeScript-only and the type inference is the whole point — tool parameter types are read from function signatures at build time and emitted into .dawn/dawn.generated.d.ts. A Python port would lose that. Use langgraph directly in Python; LangSmith deploys both.
Is Dawn production-ready?
Dawn produces deployment artifacts; the framework itself is pre-1.0 and the API surface is still moving. dawn build emits a runnable node target (server.mjs plus a hardened Dockerfile) and a langsmith target (langgraph.json) by default, plus an opt-in hono target for Cloudflare Workers and other edge runtimes; dawn start serves the node target in production on 0.0.0.0. Lock to a pinned version and read release notes between upgrades. See Deployment.
Working in Dawn
Can I drop down to raw LangGraph when I need to?
Yes — that is the point. A route's index.ts can default-export an agent() descriptor or named-export a workflow, graph, or chain; the graph shape hands you a raw StateGraph with no Dawn abstractions in the way. Mix shapes across routes in one project. See Routes.
What does dawn build actually do?
It walks your routes, runs typegen, then writes deployment artifacts for each configured build.targets (node and langsmith by default). The node target emits .dawn/build/server.mjs — which boots the real Dawn runtime (Agent Protocol, AG-UI, and the sandbox if configured) — plus a hardened Dockerfile; run it with dawn start or docker build/docker run. The langsmith target emits .dawn/build/langgraph.json plus a per-route entry file under .dawn/build/<routeSlug>.ts; each agent route's entry imports your default agent() descriptor, materializes it as a LangGraph graph, and wires in discovered tools. Each assistant_id is <routeId>#<kind> — for example /research#agent. The opt-in hono target emits .dawn/build/app.mjs plus a wrangler.toml, for edge runtimes. See Deployment.
Why a meta-framework instead of a library?
A library is something you call. A meta-framework is something you write inside. The conventions Dawn enforces — folder-as-route, co-located tools, typed state per route — only pay off when the whole project follows them, the same way Next.js routing only pays off because every page lives under app/. A library version would surface all the same boilerplate Dawn is built to delete. See Mental Model.
Operating Dawn
Can I deploy outside LangSmith?
Yes. dawn build's node target emits a server.mjs that boots the real Dawn runtime plus a hardened Dockerfile — build the image and run it wherever you run containers, or serve it directly with dawn start. This is the only deployment path that engages the execution sandbox. If you'd rather containerize the langgraph.json output instead, dawn build's langsmith target still emits it; feed .dawn/build/ to any container that runs the LangGraph runtime, but note that path does not run the Dawn runtime or the sandbox. See Deployment.
Can Dawn run on Cloudflare Workers?
Yes, for apps that fit the edge subset. Add "hono" to build.targets and dawn build emits an app.mjs plus a wrangler.toml you deploy with wrangler deploy; durable state goes to Postgres over a @neondatabase/serverless WebSocket pool, set through a DATABASE_URL binding. No nodejs_compat flag is needed. The sandbox, workspace file and shell tools, tool-output offloading, skills, and long-term memory are unavailable there, and the build fails naming them rather than degrading quietly — as does the runtime, per request, for anything that reached a filesystem-less runtime without passing that build gate.
Read Edge and Hono before you commit to this path. The evidence behind that "yes" is a gated CI lane serving real AG-UI turns under local workerd — the same binary Cloudflare runs — and not a deploy to Cloudflare itself, which nobody has performed yet. What is proven, and what is not lists the gaps that leaves, bundle size and production connection limits among them.
Can Dawn use Postgres for long-term memory?
Yes. SQLite is the default local store, but @dawn-ai/memory-pgvector provides a Postgres + pgvector backend for production and multi-instance deployments. Add pgvectorMemoryStore({ connectionString, dimensions }) to memory.store, and add openaiEmbedder() when you want hybrid keyword + vector recall. See Recall and Retrieval.
How do I gradually migrate an existing LangGraph project?
Move one graph at a time. Create a Dawn route, named-export your existing StateGraph from its index.ts as graph, and point the new assistant_id at it. Tools, prompts, and model providers come along unchanged — Dawn surrounds your code, it does not rewrite it. Once the route is live, peel state and tools out into the Dawn shapes if the ergonomics are worth it, or leave the graph as-is.