Launching today
Extella.AI
Agentic platform that evolves & builds reusable systems
35 followers
Agentic platform that evolves & builds reusable systems
35 followers
Extella is an agentic AI platform that self-evolves. It remembers what works and reuses it, so each task runs faster and cheaper. That memory lives in four layers: Rules adapt to you, Concepts build a knowledge base, Experts turn work into automations, and a KV store keeps your keys encrypted. Bring your own LLM, connect any tool (Slack, Notion, Gmail, GitHub), any GitHub library, ML model, or your own — all managed from a single workspace. By Day 30, it's a system only you have.
Absolute Cryptography
Hi Product Hunt,
I'm Vlad, one of the co-founders of Extella. Timur and I started down this road back in 2014 with a goal that sounds almost too simple when you say it out loud: build a calculator that could solve any human problem.
It's not a chatbot, nor an assistant. It's a calculator in the most literal sense — you give it a problem, it gives you back a correct solution. Getting there meant three things had to work together. It had to be modular, so it could grow without limits and build new abilities out of small pieces instead of being rewritten every time. It had to actually evolve, so every problem it solved made it permanently smarter. And it needed real intelligence on top, so it could understand a problem before solving it, pick the right tools, and get better at its own thinking over time.
That took the better part of a decade. Patents, university pilots, a long list of dead ends (we even tinkered with FPGA chips at one point because the hardware just couldn't keep up).
For most of those years the tech wasn't ready for what we were trying to do.
When LLMs finally showed up, all the pieces we'd been quietly assembling just clicked into place. Now Extella is that calculator.
One thing I'll be straight about, because most launches won't: Extella isn't magic on day one. It needs a little time to learn how you work and what "good" looks like to you. The first week, you're mostly teaching it. Around month two it's saving you real hours. By month six it's doing things you forgot you ever showed it, and your cost per task keeps dropping as your Expert library carries more of the load. You bring your own models, local or cloud, and Extella routes each task to whichever one fits, by cost and accuracy. Most AI tools wow you on day one and bore you by day thirty — this one's the other way around. Quiet at first, then it compounds.
It took us ten years to build a platform that continuously self-evolves and adapts to each user individually. Try it now on macOS 13+, Windows 11+, or Linux.
P.S. check the last slides for Product Hunt Community Perks. We are giving away 50,000 credits and launching the Build Challenge with a one-time opportunity to win some unlimited features for life. Details in the slides.
Sign up for the Build Challenge here: https://forms.gle/mtAauocmYzCcLnUW7
I’m fine with the slow start if month two actually pays off. The routing piece is what I’d want to understand first: can I set a local-only policy for certain Experts, or does Extella decide between local and cloud models per task?
Absolute Cryptography
@novamaker01 Both. And you control which.
You set the policy. Extella enforces it.
Every Expert runs on a Target — a specific device you've registered. You can pin any Expert to a local Target explicitly. That Expert will never leave your infrastructure, regardless of what the RL Router would otherwise prefer. Local-only is not a global toggle — it's a per-Expert, per-Agent, or per-Rule decision. As granular as you need.
At the Agent level, each agent has its own LLM configuration. You can point an agent at a local model — Llama via Ollama, Mistral, whatever you're running — and that agent will never make an outbound model call. Other agents in the same profile can use cloud models. They coexist in the same pipeline.
Rules and Concepts orchestrate the whole thing.
Rules are the highest-priority layer. The Router optimizes within the envelope you set, not outside it. But orchestration goes deeper than routing. Rules define when to switch models, when to escalate from a reflex to a reasoning chain, when to delegate to a different agent. Concepts carry the accumulated knowledge of what worked before — which model performed better on which task type, which pipeline failed and how it was fixed. That knowledge feeds back into every future decision. The system isn't just following your rules. It's learning from its own execution history and getting more precise about when to apply which resource.
CSPL enables auto model switching at the execution layer.
You can define a CSPL that dynamically selects its execution backend based on the task at runtime — local inference for latency-sensitive work, cloud for complex reasoning, FPGA synthesis for compute-bound algorithms. The switching logic lives in the container, not in a config file. Which means it can itself be evolved, versioned, and replaced without touching anything else in the system.
So in practice:
- Sensitive data pipeline → local Target + local LLM agent + Rule enforcing local-only → nothing leaves
- General reasoning tasks → RL Router picks the best available model, cloud or local, based on cost and accuracy
- Hardware-adjacent tasks → pinned to the device that has the FPGA or the sensors
The architecture was built for exactly this split — because in enterprise and robotics contexts, data locality isn't optional. You don't have to trust the system to make the right call on sensitive workloads. You just write the Rule, and the decision stops being a decision.
But step back for a second — because the routing question is actually the smaller story.
Claude Code is a session. When it's done, it's done. Extella persists. Every solution becomes a permanent Expert — verified, reusable, callable from chat, API, another expert, or a robot. Claude Code writes code for you. Extella builds a growing library of capabilities that outlive every conversation.
Extella also runs on anything. The same expert executes on your laptop, a server, a Raspberry Pi, or a robot — wherever the task requires. Memory accumulates permanently through Concepts. Through Sleep — fine-tuning — everything the system learns gets embedded into the model's weights. The next session starts smarter than the last.
And through multi-agent profiles, complex tasks decompose across specialized agents recursively — each with a clean context, its own LLM, its own memory and rules. No context overflow. No ceiling.
Now the part no other platform comes close to: CSPL and the 10x–1000x multiplier.
A general-purpose language carries the full weight of everything it can do. For any specific domain, most of that is irrelevant noise — tokens, ambiguity, errors, LLM cycles spent on syntax instead of meaning.
A DSL built for one domain eliminates that noise entirely. If your CSPL describes a financial strategy, there is no syntax for doing anything other than a financial strategy. The model works only with meaning. No boilerplate. No misinterpretation. No retries. A 10-line DSL description replaces 300 lines of Python. A domain-specific instruction replaces five rounds of prompt iteration.
At scale — across thousands of experts, dozens of agents, running continuously — that difference compounds into orders of magnitude: 10x, 100x, 1000x and beyond depending on domain complexity.
At the extreme end, CSPL reaches hardware. Verilog through Extella doesn't just generate code — it synthesizes directly to FPGA and dynamically builds processor architecture per task. That's Patent US 12,099,462. The architecture adapts to the algorithm, not the other way around. The limit stops being software. It becomes physics: speed of light, transistor density.
And everything above is the baseline. Zero-state behavior.
The system is adaptive by design and evolves along three axes simultaneously:
From errors and new knowledge. Every failed execution, every corrected output, every new Concept added feeds back into the system. The Expert that failed gets updated. The Rule that caused the wrong routing gets refined. The Concept that lacked context gets enriched. The system doesn't repeat mistakes it has already resolved.
From users. Every request that pushes the system past its current capabilities results in a new Expert, a new CSPL, a new Rule — permanently. One user's solution becomes infrastructure for every subsequent similar task. You don't file a feature request and wait for a release. You describe what you need, and the system builds it.
From researchers. When a new paper drops — a better fine-tuning method, a new routing algorithm, a more efficient inference architecture — you don't wait for Anthropic to ship it. You implement it as an Expert or a new CSPL container. The Sleep expert gets replaced with the new method. The RL Router gets updated with the new algorithm. Research becomes capability in hours, not quarters.
This is the distinction that matters:
Anthropic updates the product for the user — a team decides what gets built, you receive it, you adapt to it.
Extella is updated by the user from a single request. The system is more capable than it was this morning — not because a company shipped a release, but because you had a conversation.
Extella is the first genuinely self-evolving AI — not in the marketing sense, but in the literal engineering sense. Every component of the system — memory, reasoning, execution, routing, hardware interaction — is implemented as an Expert. Which means every component inherits the same three planes of evolution: the code grows more complex, the description evolves, the execution layer gets replaced with something better.
The system improves its own way of improving.
Every other AI platform has a ceiling defined by its developers. Extella's ceiling is defined by what is physically computable.
They are tools. Extella is the first system that builds its own tools — and then builds better tools for building tools.
Congrats on the launch! This looks very promising. So does that mean that due to the architecture it basically.... doesn't forget anything? What if things get contradictory and/or confusing, how does the system handle it?
Absolute Cryptography
What does your platform do that Claude can't?
Absolute Cryptography
@perizatka_03 Claude Code is an excellent tool. But it's a session. When it's done, it's done.
Extella persists.
Every solution becomes a permanent Expert — a verified, reusable module callable from anywhere: chat, API, another expert, a robot. Claude Code writes code for you. Extella builds a growing library of capabilities that outlive every conversation.
Extella runs on anything.
Claude Code runs in your terminal. Extella runs on any device you connect — your laptop, a server, a Raspberry Pi, a robot. Through Targets, the same expert executes wherever the task requires.
Extella has memory that evolves.
Concepts accumulate knowledge permanently. Rules shape behavior. Through Sleep — fine-tuning — everything the system learns gets embedded into the model's weights. The next session starts smarter than the last one.
Extella is multi-agent with infinite context.
Claude Code is one model, one context window. Extella decomposes complex tasks across specialized agents recursively — each with a clean context, its own LLM, its own memory and rules. No context overflow. No ceiling.
Now the part no other platform comes close to: CSPL.
When Anthropic ships a new feature to Claude Code, an engineer wrote it, reviewed it, deployed it. You waited for it. You had no say in what got built.
In Extella, if the execution layer doesn't do what you need — you define a new one. Not a plugin. Not a config. A new CSPL container that teaches Extella how to interpret an entirely new class of experts.
Want experts that execute as Rust? Define a CSPL. Want a domain-specific language that describes a financial strategy, a molecular structure, a neural architecture, a CNC toolpath — and have Extella execute it natively? Build that CSPL. Now every expert written in that language runs correctly by construction. The language itself prevents incorrect code.
And this is where the 10x–1000x efficiency comes from.
A general-purpose language like Python carries the full weight of everything it can do. For any specific domain, most of that is irrelevant noise — and noise means tokens, means ambiguity, means errors, means LLM cycles spent on syntax instead of meaning.
A DSL built for one domain eliminates that noise entirely. If your CSPL describes a financial strategy, there is no syntax for doing anything other than a financial strategy. The model works only with meaning. No boilerplate. No misinterpretation. No retries.
The more constrained the language, the less the model needs to do — and the more reliably it does it. That's where the multiplier comes from. A 10-line DSL description replaces 300 lines of Python. A domain-specific instruction replaces five rounds of prompt iteration. At scale — across thousands of experts, dozens of agents, running continuously — that difference compounds into orders of magnitude.
At the extreme end, CSPL reaches hardware. Verilog through Extella doesn't just generate code — it synthesizes directly to FPGA and dynamically builds processor architecture per task. That's Patent US 12,099,462. The architecture adapts to the algorithm, not the other way around. The limit stops being software. It becomes physics: speed of light, transistor density.
This is the distinction that matters:
Anthropic updates the product for the user — a team decides what gets built, you receive it, you adapt to it.
Extella is updated by the user from a single request. You describe what you need. Extella builds the Expert, the CSPL, the Rules. The capability becomes permanent. The system is more capable than it was this morning — not because a company shipped a release, but because you had a conversation.
Extella is the first genuinely self-evolving AI — not in the marketing sense, but in the literal engineering sense. The system's own components — memory, reasoning, execution, hardware interaction — are all implemented as Experts. Which means they all inherit the same three planes of evolution: the code grows more complex, the description evolves, the execution layer gets replaced with something better.
The system improves its own way of improving.
Every other AI platform has a ceiling defined by its developers. Extella's ceiling is defined by what is physically computable.
They are tools. Extella is the first system that builds its own tools — and then builds better tools for building tools.
I tried it and it's really impressive.
It took me some time to figure it out, but it works much better than Gemini for me.
I asked it to find an old autosave file that I had lost with specific changes in it, and it found it!
I would have spent hours doing it myself.
It seems that you can connect all your tools and file systems and use it as a personal operating system with memory.
I wonder if you are planning to make a mobile version, which would be more convenient)
Good luck with ur launch!