I want to show you a number: 166 MB.
That's how much disk space LangChain takes up. For a library whose entire job is to connect a few LLM API calls together.
Now here's another number: 10 KB.
That's Orbit. A Lua framework that does much of what LangChain does — agents, multi-agent systems, RAG, map-reduce, structured workflows — in roughly 160 lines of code.
Let that sink in.
The Framework Size Wall of Shame
| Framework | Lines of Code | Install Size |
|---|---|---|
| LangChain | 405K | 166 MB |
| CrewAI | 18K | 173 MB |
| LangGraph | 37K | 51 MB |
| AutoGen | 7K | 26 MB |
| Orbit | ~160 | ~10 KB |
I'm not sharing this to dunk on those projects. I'm sharing it because it forces a real question:
What are we actually paying for?
The Core Idea: LLM Apps Are Just Graphs
Orbit makes one bet: every LLM application is a directed graph. Nodes execute, return a string, and that string routes to the next node. Shared state flows through like a lightweight message bus.
Here's what that looks like in practice:
local fetch = pf.node(function(shared)
shared.value = 42
return 'ok'
end)
local process = pf.node(function(shared)
if shared.value > 40 then
return 'large'
end
return 'small'
end)
fetch:to('ok', process)
No decorators. No YAML. No plugin registries. No lifecycle hooks you have to Google.
Just flow.
It's less "framework" and more "state machine with a good API." And once you see it that way, you start wondering why AI tooling ever needed to be more complicated.
Why Lua? (Seriously, Hear This Out)
I know. Lua in 2025 raises eyebrows. But the choice isn't nostalgic — it's strategic.
Lua has:
- A tiny embeddable runtime
- Native coroutine support
- Minimal syntax surface
- Extreme portability
But here's the angle nobody's talking about: Lua is great for AI-generated code.
Big frameworks are hard for LLMs to code against. The API surface is enormous, abstractions are layered 5 levels deep, and hidden behavior lurks everywhere. The model hallucinates. You debug. Everyone suffers.
Orbit's entire runtime fits in a context window. An LLM can hold the whole framework in its head while generating node implementations. That means:
- Fewer hallucinated API calls
- More deterministic generation
- Easier error repair
- Actually usable autonomous coding workflows
This reframes what Orbit is. It's not just a small framework. It's a framework deliberately designed for AI-generated code. That's a different product category entirely.
Composability > Abstraction
Modern AI frameworks love to hardcode concepts: agents, tools, memories, chains, evaluators. Those abstractions feel helpful until they become constraints — and they always become constraints eventually.
Orbit takes the opposite approach. It defines exactly three primitives:
- Nodes (execution units)
- Transitions (routing logic)
- Shared state (communication)
Agents? That's a graph topology. RAG? Graph topology. Multi-agent coordination? Still just a graph topology. Nothing is hardcoded because nothing needs to be.
It's the difference between a platform and a primitive. Platforms make assumptions about your use case. Primitives let you build the platform you actually need.
The Psychology of Small
There's something real that happens when a framework is 160 lines long.
You read it. You understand the whole thing. You stop being afraid to fork it or modify it or throw it away. You stop treating the framework as infrastructure and start treating it as readable code.
Compare that to the experience of debugging a LangChain agent at 2am. You're not debugging your code anymore. You're archaeologizing someone else's abstraction tower.
Orbit is closer to Unix philosophy than to enterprise software: do one thing, do it well, compose freely.
The SQLite Parallel
SQLite is the most deployed database in the world. It won not by being the most powerful, but by refusing to become enterprise middleware. Single file. No server. Copy-paste deployment. Zero operational complexity.
Orbit is aiming for the same lane in AI orchestration. And that niche is genuinely underserved:
- Local-first AI apps
- Edge deployments
- Embedded agents
- Offline workflows
- Experimental architectures
Every heavy framework optimizes for the SaaS cloud ecosystem. Nobody's optimizing for portability. Orbit is.
Where This Is Headed
Orbit ends its pitch with: "Enable LLMs to Program Themselves."
That sounds like conference slide hyperbole. But given the architecture, there's something concrete underneath it.
If AI systems are going to generate and modify software autonomously, the runtimes they target need to be smaller, more predictable, and easier to reason about. Massive frameworks with sprawling APIs are not that. A 160-line graph executor with shared state absolutely could be.
We're in the post-hype phase of AI tooling. The first wave gave us abstraction stacks. The second wave is quietly dismantling them — direct API calls, explicit control flow, minimal runtimes, graph execution.
Orbit fits that second wave perfectly.
The Takeaway
You probably won't swap LangChain for Orbit tomorrow. But Orbit makes you ask the right question: what is all that code actually doing for you?
If the answer is "handling complexity I didn't need in the first place," that's worth sitting with.
The industry needs more 160-line ideas.
Have you tried building with minimal AI frameworks? Dropped heavyweight orchestration for something leaner? Would love to hear what the ecosystem looks like from your side — drop it in the comments.
Top comments (0)