Compare
Linda vs CopilotKit
CopilotKit gives you React components for AI copilots; Linda gives you a browser agent that reads your live DOM. Same neighborhood, different bets. Here's when each wins.
Pick Linda when…
- You want the agent to read the DOM without wiring useCopilotReadable for every state slice.
- You're not on React, or you use multiple frameworks.
- You need the agent to write back to the page — fill forms, click buttons.
- You want browser-side file parsing without uploading.
- You need multi-agent handoffs (e.g. exit-intent rescue).
Pick CopilotKit when…
- You're deeply on React and want first-class React components.
- Your AI feature is read-only Q&A in a sidebar.
- You like the CopilotKit Cloud + Co-Agents abstractions.
The architectural difference
CopilotKit wraps your React app in <CopilotKit> and asks you to mark
state with useCopilotReadable and actions with useCopilotAction. The agent
sees what you let it see.
Linda mounts a VFS over your live page. /page/dom.html is the current
DOM snapshot. The agent sees what the user sees.
// CopilotKit — explicit state plumbing
useCopilotReadable({ description: "User's account", value: account });
useCopilotReadable({ description: "Current deal", value: deal });
useCopilotAction({ name: "updateDeal", parameters: [...], handler: async (args) => {...} });
// Linda — no plumbing
<Linda config={...} />
// Agent reads /page/dom.html when it needs to know what's on screen.The plumbing approach is cleaner for greenfield apps where state is already React-native. The VFS approach scales better when your page has data from multiple sources, you don’t own the rendering, or you want the agent to read anything the user is looking at.
Compare on the dimensions
| Dimension | CopilotKit | Linda |
|---|---|---|
| Framework | React-first | Framework-agnostic |
| How the agent sees state | useCopilotReadable | Live DOM via /page |
| How the agent writes state | useCopilotAction | DOM events on <input>s |
| File uploads | Send to backend | Browser-side parsers |
| Multi-agent | Co-Agents (paid) | Built-in |
| MCP | Limited | Client + server |
| Bundle size | ~80 KB | ~35 KB |
| License | MIT | MIT |
| Hosted offering | Yes (cloud) | No (pure SDK) |
What CopilotKit does better
- First-class React. If your team breathes React, CopilotKit’s component APIs are ergonomic in a way Linda’s framework-agnostic core isn’t.
- Co-Agents. CopilotKit’s Co-Agents abstraction (paid) bundles multi-agent + state with nice React ergonomics.
- Sidebar Q&A. If all you want is a Q&A sidebar, CopilotKit ships that in 5 lines.
What Linda does better
- No state plumbing. Linda reads the DOM directly. No
useCopilotReadableper slice. - Agent writes the page. Linda’s PageMount intercepts writes and fires real DOM events. Your existing form validation, React state, jQuery — all just works.
- Browser-side files. PDF, DOCX, OCR — all in-browser via
@linda/parsers-*. - MCP server mode. Expose your page to Claude Desktop with two lines.
- Multi-agent + triggers ship in the OSS core, not behind a paid tier.
The honest verdict
If your AI feature is “answer questions about state in my React app,” pick CopilotKit. The DX is great.
If your AI feature is “let the agent operate on the page like a colleague,” pick Linda. The DOM is the source of truth.
If you’re building both — a sidebar Q&A plus an agent that fills forms —
pick Linda and use its slash commands (/help, /skills) for the Q&A case.
You’ll get one consistent stack.
FAQ
Can I use both?
Yes. CopilotKit handles the sidebar UX; Linda handles the agent-on-the-page work. They don't conflict — different scopes.
Does Linda have React components?
Yes — @linda/react. But the core SDK is framework-agnostic; the chat UI renders into a Shadow DOM.
Ship an agent-driven flow this afternoon.
Install Linda, paste a config, and your form turns into an agent that fills its own inputs.