Rysh vs LangChain and CrewAI: frameworks are Lego — you still operate the tower
You can absolutely build your agent platform with a framework. The question is whether you want to operate it forever.
"We'll just build it with LangChain."
Every engineering team says this. It's not naive — it's almost right. LangChain, LlamaIndex, and CrewAI are genuinely good at what they are: flexible libraries with huge ecosystems for wiring LLMs to tools, data, and each other. If agents are your product's core IP, a framework is probably the correct call.
But most teams don't want to build an agent platform. They want to have one. And that difference is about six months of work you didn't plan for.
Frameworks are Lego
A framework hands you excellent bricks: chains, tool abstractions, memory classes, multi-agent crews. What it doesn't hand you is the tower — assembled, inspected, and standing in production with people leaning on it.
The demo takes a weekend. Here's the part that doesn't:
- Tool plumbing. File edit with previews, shell execution that doesn't nuke a machine, git operations, web fetch, code search. Each tool needs error handling, timeouts, output limits. Multiply by every tool your agents need.
- Approval and permission policy. Which operations run freely? Which wait for a human? Who decides, and where does the prompt appear? This is product design and infrastructure.
- Secret handling. Your agents will read env vars and config files. What stops a credential from riding along in a prompt to the provider?
- Multi-tenant isolation. The moment two teams share the deployment, you're designing tenancy boundaries at the messaging layer.
- Observability. "The agent did something weird yesterday" — can anyone see what? Per-tool-call, in real time, not grepped from logs?
- Channel connectors. Slack apps, IMAP/SMTP, web chat widgets. Each with auth, threading, retries, and rate limits.
- A UI. Engineers might live with a script. Nobody else will.
That's the boring 80%. None of it is intellectually hard. All of it is mandatory, and all of it is yours to maintain forever — through every framework major-version bump.
What rysh ships instead
Rysh is the assembled tower: the IDE and the runtime and the governance, out of the box.
- An agent is a markdown skill file — system prompt, config, done. It lives in git and gets code-reviewed like everything else.
- 46+ built-in tools with approval gates on the dangerous ones and coloured diff previews before an edit lands.
- Every tool call visible in a pane, live — observability is the foundation, not a dashboard bolted on later.
- Multi-tenant isolation at the messaging layer (NATS subject ACLs) — actual security engineering, not a config flag.
- Channels included: the same skill file answers in your terminal, on Slack, over email, and in website chat today (WhatsApp and phone are roadmap, not live).
- Collaboration: share a pane with a teammate — view or control — while an agent works in it.
And the engine runs on Claude with your own API key. We're not claiming a smarter model than the one your framework would call — we're claiming you skip the six months of scaffolding around it.
Side by side
| LangChain / CrewAI | rysh | |
|---|---|---|
| What you get | Libraries + abstractions | Running product: IDE + runtime + governance |
| Agent definition | Code you write | Markdown skill file in git |
| Tooling | Bring/build your own | 46+ built-in, approval-gated |
| Observability | You instrument it | Every tool call live in a pane |
| Isolation & tenancy | You design it | NATS subject-ACL isolation built in |
| Channels | You integrate each | Slack, email, web chat included |
| Flexibility ceiling | Effectively unlimited | Platform-shaped (skill files, MCP, your APIs) |
| Ops burden | Yours, forever | Self-hostable binary; rysh is the product |
When to pick a framework
Genuinely, pick LangChain / LlamaIndex / CrewAI when:
- Agents are your product. You're selling the agent behavior itself and need control down to the token.
- Your pipeline is deeply custom — exotic retrieval, custom planners, research-grade orchestration a product can't and shouldn't express.
- You're embedding agent behavior inside your own application, not running a workspace for people.
- You're learning. There is no better way to understand agents than assembling one from bricks.
The ecosystems are enormous, the communities are great, and the flexibility is real. Nothing platform-shaped will ever match a library's ceiling.
When to pick rysh
Pick rysh when the honest goal is "our team runs governed agents that do real work" — not "we maintain an agent infrastructure codebase."
- You want agents working today, with approvals and audit visibility on day one.
- You want your platform team building your product, not tool plumbing.
- You want one definition running in the terminal and on your support channels.
- You want to own it: self-hostable, your infra, your Anthropic key, your data. (Not open source — we say self-hostable and mean exactly that.)
And if you've already built custom tools? Rysh is an MCP client — external MCP servers plug straight into the engine. Your framework work isn't wasted; it becomes a tool rysh agents can call.
Frameworks are Lego. Lego is wonderful. But somebody has to dust the tower, and it shouldn't be your senior engineers.
We're early-stage and recruiting design partners — teams who'd rather operate agents than agent infrastructure. Direct line to the founders, roadmap shaped by your workflow: become a design partner →
More in this series: Rysh vs building it yourself · What it actually means to be an AI-native company