Today, the most expensive models in the world spend their day searching files, fixing typos and pushing to git. Maralabs builds Socrates, the layer that sends every piece of work to the cheapest intelligence that can do it right. From your laptop to the frontier.
Open source for developers. Licensed for companies.
Models keep getting smarter and cheaper per token. Yet AI bills keep climbing, because most tools send most tasks to the biggest model they can reach. A trivial rename and a hard architecture decision cost the same frontier price. Meanwhile, the laptops and GPU servers companies already own sit idle.
We think the future of AI isn't one giant model doing everything. It's many kinds of intelligence, small and large, local and remote, cooperating efficiently. The model on your laptop handles the routine. Your own servers handle the heavy lifting. The frontier handles what truly needs it. Maralabs exists to build the system that makes that cooperation work.
Choosing the right model for a request is a good start. Socrates goes further: it changes how the work itself gets done.
| Frontier only | Model router | Socrates | |
|---|---|---|---|
| Who does trivial work | The most expensive model | A cheaper cloud model | A model on your own machine |
| Uses hardware you already own | No | No | Laptops and GPU servers |
| Context for the big model | Reads your repo itself | Reads your repo itself | Pre-processed locally |
| Hands work back down | No | No | Yes, after the hard part |
| Checks the result before you see it | Depends on the agent | Depends on the agent | Always, with your tests |
// Compared at the level of approach, not measured results. Our benchmark will compare them on cost per solved task.
A local-first layer for AI coding agents. It splits every request into steps, runs each one at the lowest level that can handle it, and escalates only when it has to. The frontier model reasons about the hard part, then hands the rest back down.
It sits underneath the tools developers already use. Nothing to switch, nothing to relearn. Just a smaller bill.
Every result is verified with your own tests and tools before it reaches you, and every dollar is accounted for.
A developer asks Socrates to fix a performance regression. Most of the work never touches a frontier model. The one step that does gets a focused brief instead of the whole repo.
Finds the relevant code, runs the benchmarks and diffs the recent changes with deterministic tools.
A small model on the developer's machine drafts what's going on.
If the problem is beyond the small model, a larger one on the company's GPUs takes over.
Only if needed and allowed by policy. Claude, Codex or Gemini design the fix.
The straightforward work goes back down: apply the patch, run the tests, confirm the regression is gone.
We've seen AI coding usage reach thousands of dollars in a single day, most of it spent on work that never needed a frontier model. So we're building what we wished we had:
18 years of performance-critical C++, working on the op libraries, JIT compilers and GPU kernels that AI models actually run on. This is his day job on an AI accelerator stack, not a weekend skill.
We launch only when the numbers hold up. Here's the path.
Local and frontier models working together, every task logged with its cost.
Developers using Socrates on real work, on real hardware.
The core goes public, free for every developer, with the benchmark alongside it.
SSO, policies, team cost dashboards and a managed server level on your own GPUs.
Small models distilled automatically for each kind of development work and each machine.
The core is open source and free for individuals and small teams. Companies pay for what only companies need: SSO, policies on what code may reach a frontier model, cost dashboards by team, audit logs and support.
No. We don't compete with Anthropic, OpenAI or Google on model intelligence. Socrates makes their models more cost-efficient by keeping them focused on the work that needs them. Every time models or hardware improve, Socrates gets better too.
A router decides which model answers a request. Socrates decides how the work gets done: it prepares context locally, splits tasks into steps, runs each at the cheapest capable level, hands follow-up work back down, and verifies the result before you see it. Routing is one piece of that.
They only get work they can handle, and every change is verified with your own tests and tools. When in doubt, Socrates escalates. Our benchmark measures success rate alongside cost, so any quality loss would show up in public.
Only when a step is escalated to a frontier model, and only the context that step needs. Companies can set policies that keep specific code on local or self-hosted models. We never train on your code.
Socrates is in development. Join the waitlist for early access to the alpha. If you're a company interested in a pilot, write to us.
Join the Socrates waitlist for early access and our benchmark results. Companies interested in a pilot can write to us directly.