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; 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 (both 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. 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 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 Memory.
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.