Launching today
Extella.AI
Agentic platform that evolves & builds reusable systems
68 followers
Agentic platform that evolves & builds reusable systems
68 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
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
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.
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!
Absolute Cryptography
@ella_bye Thank you! Finding lost files is one of those quiet wins that actually saves your day.
You can already use Extella from your phone via the web version and run Experts as long as one of your desktop devices is online. So it's usable today — you just need a machine running in the background.
A full mobile app is on the roadmap — where your phone will also act as a target device. 🙂
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.
Great app. I used it to build an AI layer on top of my bar’s CRM. It automatically calculates salaries and bonuses for employees, generates financial reports, monitors suspicious receipt deletions in the accounting system, assigns tasks to the manager, and tracks their deadlines. It also helps with purchasing orders and monitors the markup.
Wishing the team the best of luck!
Absolute Cryptography
@azizb This is exactly what Extella is built for — not just automating one task, but becoming the operational brain of an entire business. Thanks for sharing!
Voquill
Intereting. Just curious how this handles conflicts or inconsistencies when it starts learning across different workflows. Good luck!
Absolute Cryptography
@henry_habib Good question — and an honest one.
Conflicts surface explicitly, not silently. When two Rules contradict, the agent flags it during interaction. You decide which stays, or you merge them into a new Rule that resolves the tension. Nothing conflicting quietly accumulates in the background.
For knowledge across workflows, Concepts handle it the same way. When similar knowledge comes in from different sources, the system deduplicates and merges rather than stacking duplicates. If there's a genuine inconsistency — two workflows that learned opposite things — it gets surfaced for human resolution, not auto-resolved by the system.
But here's where it gets more interesting.
You can teach the agent exactly how to handle ambiguity — not just flag it, but resolve it. You define Rules for how to research a contested claim, how to fact-check, how to assess recency and relevance, how to weigh conflicting sources by importance. The agent learns your epistemology, not just your preferences. Once those Rules exist, the same judgment you'd apply manually gets applied automatically — every time, at scale.
You can also teach the agent to recognize the boundaries of its own knowledge. Rules and Concepts can encode a self-assessment protocol: when the agent hits a gap, it doesn't guess — it identifies what it doesn't know, flags it, and can trigger an automated research or learning workflow to close that gap. It learns to know what it doesn't know.
And then the final step: you automate the configuration work itself. Once the agent understands your standards for conflict resolution, fact-checking, and self-improvement — you build Experts that handle that process automatically. New knowledge comes in, gets verified against your criteria, gets merged or flagged, gets added to memory — without you touching it.
The goal of human involvement is not to be always present. It's to teach the system well enough once that it stops needing you for that class of decisions entirely. Every hour you spend teaching the agent reduces the next thousand hours of manual intervention to zero.
That's the trajectory the architecture is designed for. You start in the loop. You work yourself out of it.
Thank you for asking!