The model call is the easy part. The year of plumbing around it is not: durable sessions, interrupts, retries, chat UI, tools, skills, safe execution. Catamorphic ships all of it. Mount it on your backend, plug in your agent setup, and your users have a copilot that does real work.
Installable packages are coming soon. The full source code is open source and available on GitHub.
// the plumbing
The same session engine and chat machinery that power Work for desktop, available in the open-source implementation. Installable packages are coming soon.
shadcn-style components you own the source of (agent-chat, chat-timeline, sessions-list) on headless hooks (useAgentChat, useAgentSessions) when you'd rather build your own.
Turns persist server-side with honest state: an interrupted turn settles as interrupted, activity indicators always converge, transient failures auto-retry with backoff, and a lost in-memory session re-anchors from the transcript.
A registry of named agents over pluggable harnesses: the AI SDK loop on any model, Claude Code, or Codex. Projects can commit their own agent definitions as reviewable files, consent-gated before one spends a user's credentials. Switching agents needs no server restart and no rewrite of your chat surface.
Stage skills into the agent's working context so it knows your product's domain, and hand it typed tools for the actions you allow. The agent you plug in is yours; Catamorphic is the socket.
The agent doesn't just answer, it produces: workflows, apps, and file changes, written in a sandbox and proposed as drafts before anything lands. Not a FAQ bot with your logo on it.
Structured questions when the agent is genuinely blocked, message queueing mid-turn, interrupts that actually cancel, and per-tenant identity on every request. The conversation behaves like a product, not a demo.
// your product, your rules
Catamorphic ships mechanism plus good defaults; every default resolves through your config. The desktop app consumes the same hooks as any other embedder.
Everything user-built apps render flows from your theme tokens: fonts, colors, radii, motion timing, density. Pass nothing and you get neutral defaults; pass your own stylesheet and restyle the kit wholesale. A user's app looks native in your product, not in ours.
The skills that teach agents how to build, the project templates, and the standing prompt are all replaceable through config hooks. Keep our defaults, extend them, or swap in your own house style; agents in your product build to your standards, not ours.
One plugin can bundle capability providers, project lifecycle hooks, trigger kinds, and tool kinds. Users attach plugins to projects; only your engineers register code into the host process at deploy time. The trust boundary is structural, not a convention.
// how it goes in
Three pieces, all replaceable: the backend engine, the chat surface, and the agent you plug into it.
Boot createCatamorphic on your Postgres, register the Fastify plugin, bind identity from your auth. Sessions, runs, and projects come with it.
Explore the chat components and headless hooks in the source. They compose into your own design system, with streaming, history, and error recovery. Installable packages are coming soon.
Pick a harness, choose the model, stage your skills, register your tools. Everything the agent may do is something you handed it.
They describe what they want; the agent asks when it must, builds workflows and apps when asked, and its sessions survive deploys, restarts, and bad networks.
Workflows are what it builds. Apps are what it ships. The copilot is how your users meet both. One engine, embedded in your product, every layer yours to swap.