AI work optimization platform
Xentient is Nandromeda’s architect: the brain that plans, manages and supervises the tasks you give to AI, so each one is done correctly with the best balance of performance and cost. Its aim is simple: finish every task successfully, as economically as possible.
Early access for teams that use AI at work.
Built to work across the models you already use, and the ones that come next.
AI doesn’t need one model for everything. It needs the right intelligence for the job—and a way to know when the job is actually done.
A cheap AI that gets it wrong isn’t cheap. Every retry, every check and every hour spent fixing a bad answer is part of the bill. So we measure what a successfully completed task costs, all in.
#
Hover or tap a task to follow its path.
Illustrative example, not benchmark data.
attempts, retries, checks, fixes
checked and accepted
the number we work to lower
Plan, run, verify, learn: the core of Xentient’s six-stage system. We track one number: what it costs to get a task done right, not how many tokens you use.
Xentient, the architect, reads the task, works out what a good result looks like and plans the most efficient route to it, with quality first.
The system does the work, using only what the task actually requires.
The result is verified against the task’s requirements. If it doesn’t pass, the system revises the approach and tries again.
Xentient remembers what worked and what didn’t, so similar work can start smarter next time.
An illustration of the path, not a live run: what happens between the task and the answer.
Xentient reads the task and defines what “done right” means.
It records what worked, so the next similar task starts smarter.
Xentient doesn’t throw maximum effort at every task, and it doesn’t take a first answer on trust. When verification fails, it moves to a more suitable approach and tries again.
The first attempt got it right, so you paid only for what the task needed.
Verification failed once, so Xentient moved to a more suitable approach and passed it.
If nothing passes the check, the task is flagged, not returned as if it were done.
Plain commitments, in place of numbers we haven’t earned yet.
the number we work to lower
Every result is checked against what you asked for before it reaches you. If it fails, we fix it, not you.
We publish a result only when we can show the method and the raw data. Until then, we say so.
We earn when you save. Pricing is tied to the savings we can verify, not to how much AI you burn.
We aim to keep nothing we don’t need, and we’ll publish our data policy before launch.
founded in Istanbul, in September, to make AI work cost less to get right.
results published so far. The benchmark is in progress, and we’ll publish the method and the raw numbers.
We don't optimize tokens. We optimize successful AI work.
Nandromeda · Istanbul
We’re pre-launch, so there’s no price list yet. This is the shape it will take.
A platform fee plus a share of the savings we verify, so we earn when you save.
Start free. Upgrade when you need more.
Join the waitlist. Pricing is announced before launch.
I started Nandromeda because AI is already good enough to do real work, yet far too much of that work is wasted. The wrong model gets picked, nobody checks the answer, and you pay for every retry.
Xentient is our answer: an architect that plans each task, supervises it, verifies the result and learns from what happened. We’re building it in Istanbul, and we hold ourselves to one number: what it costs to get a task done right.
We’re opening to our first pilot teams now. If this is a problem you have, I’d love to hear from you.
Eniola Y. Oriyomi
Founder & CEO, Nandromeda
We’re opening to our first pilot teams. Tell us where to reach you and we’ll show you what your AI tasks could cost.
We'll reply personally — no auto-generated sales sequence.
Something else on your mind? Write to us and we’ll respond soon.
Nandromeda is an artificial intelligence (AI) optimization company headquartered in Istanbul, Türkiye. Its flagship product is Xentient, an AI architecture engine for planning, executing, verifying, and optimizing AI work. Founded in September 2026, Nandromeda focuses on optimizing AI usage and the cost of successful AI work. The company is privately held and is currently raising $900,000 in pre-seed financing through a SAFE with a $7.5 million valuation cap.
A router picks a model for each request. Xentient runs the whole operation: it defines what “done” means, plans the work, executes it, verifies the result and learns from the outcome. Choosing a model is just one of the decisions it can make.
No. Xentient is designed to work with the AI models you already use, from the big providers to open models.
We define what “done” means before the work starts, then verify the result against it with a test, a rule or a second opinion. Our metric is cost per successful task. We’ll publish the method and the raw results when the benchmark is ready.
Not yet. We’re pre-launch and building with our first pilot teams. Join the waitlist and we’ll let you know when there’s a place for you.
The design, the metric we measure (cost per successful task) and the API sketch are on the . Investors will find the full picture on the .
Pay for results, not tokens.
Xentient is Nandromeda’s AI work optimization engine. It runs the whole operation: it plans each task, executes it with the most suitable resources, verifies the result and learns from it, so every job gets done right at the lowest total cost.
Pick a task — see how it plays out, three ways:
Fix cost assumed:
Estimates for illustration: cost per successful task = model spend + fixing the failures, per task. Xentient figures are placeholders — not yet confirmed; tests are still being done.
Xentient is Nandromeda’s AI work optimization engine. It sits between your application and the AI systems you already use, with one job: get each task done right at the lowest total cost.
It isn’t a new AI model, and it isn’t just a router. Choosing a model is one lever among many. Xentient can trim unnecessary context, reuse cached work, break complex tasks into more efficient steps, or schedule non-urgent work when it makes economic sense. Then it checks the result.
A cheap answer that’s wrong isn’t cheap. That’s why Xentient optimizes for cost per successful task: total AI execution cost divided by the tasks that actually succeeded.
Cost per successful task = total execution cost ÷ successfully completed tasks
And it learns. Every outcome gives Xentient more evidence about what works, so the longer it runs on your work, the better it understands what “done right” means for you, and the more efficiently it can pursue it. The detailed scoring and evaluation logic is intentionally kept close for now.
Six stages. The core loop is Plan → Run → Verify → Learn. Understand defines what success means before the loop begins; Advise uses what Xentient learns to proactively improve future work. Work only leaves the loop when it passes.
What does “done” look like? The stakes, the rules, the budget, the deadline.
The most efficient path likely to succeed, quality first: approach · resources · prompt · cache · split.
The system executes the plan, adapting resources to the work as it unfolds, with failover if a provider is slow or down.
The result is verified, not assumed: tests, schemas, exact answers, a judge. If it fails, the system adapts and tries again. Only successful results leave.
Record what it cost and whether it worked — every prediction gets sharper.
Proactive suggestions to cut cost or failures, applied when you allow it.
Everything above is tuned per customer and stays private to them — the enterprise story.
ButterflyX is our own AI app built on Xentient. Every message becomes a real Xentient task: planned, executed, verified and learned from. The chips under each reply make the process visible: how Xentient ran the task, how the result was checked, and whether it passed.
You get the savings when they're real, and the quality floor when they're not.
Honest status: plan, run and verify are what we’re building and benchmarking now. Learning and personalization come with pilots; the advisor comes later. No result is published yet.
One integration point in front of your existing model calls. Xentient doesn't replace your models — it decides how each task should run across the ones you already use, and hands back only work that passed. Your quality bar stays yours.
Xentient is being built alongside its first pilot teams. Leave your email and you'll hear first — when the benchmark lands, and when pilot slots open.
No spam — just a note when there's a pilot slot open.
Nano changes. Andromeda outcomes.
MISSION
We exist to strip the waste out of running AI — every oversized model call, every failed attempt, every answer someone has to redo. Wasted AI spend is a tax on innovation. Our mission is to make sure it stops deciding what a team can afford to build.
VISION
We think about this the way engineers think about compilers: a layer beneath the code that optimizes automatically. We want to be that layer for intelligence — starting with Xentient, which lowers the cost of every successful AI task, and reaching over time toward the model and chip layers beneath it. Not a bigger model. A smarter layer underneath all of them.
ORIGIN
The name stacks three ideas: Nano, the smallest scale of change. NAND, the logic gate that's functionally complete on its own. And Andromeda, our nearest large galactic neighbor, roughly a trillion stars. The smallest, most unglamorous optimizations compound into differences too large to ignore.
ARTICLES · COMPANY THESIS
Most teams pick one model per feature and stop thinking about it — a reasonable default, and a quietly expensive one. The invoice counts tokens, but the real cost includes every retry, every wrong answer and every human fix. The unit that matters is the successful task. Xentient exists to make it the number every AI decision is judged by.
A NAND gate is almost nothing by itself — a handful of transistors — yet every digital system reduces to compositions of gates like it. One task done right for a little less saves a fraction of a cent. Multiply that across every task a growing product runs, for years, and the fraction becomes the difference between an AI bill being background noise or an existential cost.
Roadmap
Directional, not a fixed schedule.
Now
Xentient core loop + public benchmark
Building plan → run → verify → learn, and measuring cost per successful task in the open.
Next
Learning, personalization & pilots
Outcome learning tuned per customer with the first design partners; pricing on verified savings. ButterflyX early access.
Later
Advisor, then dedicated small models
Proactive suggestions customers can accept; then small purpose-built models for the tasks they run most. Then Nandromeda's own models, in ButterflyX and through the API.
Moonshot
Independent enterprise LLM deployments
Private, efficiency-optimized deployments for companies wanting independence from big AI vendors.
Careers
No formal open roles yet — Nandromeda is early and small. But if cutting the waste out of running AI in production is a mission you want to help build, we want to hear from you.
Especially useful right now: ML/infra engineers, and anyone who's shipped LLM products in production and felt the cost pain firsthand.
Tell us what you'd want to work on — no formal application needed at this stage.
Press kit
Logo files and extended brand assets available on request — email hello@nandromeda.com.
FOR PROSPECTIVE INVESTORS
We're an Istanbul-based AI work optimization company, working in the layer between applications and the models they call. Xentient, our AI work optimization engine, gets each AI task done right at the lowest cost that still meets the quality bar, and gets better with every task.
We don't optimize tokens. We optimize successful AI work.
Full-screen, fourteen slides, about three minutes. The written version is below either way.
OR FLIP THROUGH IT HERE
Swipe, or tap a thumbnail. Tap the slide to open it full-screen.
THE PROBLEM
Teams default nearly all traffic to their single most capable model, regardless of what each task actually needs. That compounds silently until the AI infrastructure line item rivals headcount — and it's getting worse, not better, as agentic workflows call models more often and in longer chains. Gartner projects inference cost per agentic workflow could increase more than fivefold through 2028, even as per-token prices keep falling (Gartner, Aug 2026). AI gets cheaper per token and more expensive per business outcome at the same time — that paradox is the market.
THE SOLUTION
Xentient sits in front of existing AI calls and runs each task through a loop: understand what “done” means, plan the most efficient path likely to succeed, run it, verify the result, and revise the approach only when it fails. Every outcome is recorded, so it learns — and, per customer, personalizes. One integration point, no retraining. The metric isn't tokens saved — it's cost per successful task: everything spent, retries included, divided by the tasks that actually succeeded.
One company, one engine. Enterprises and developers use Xentient through our API, priced against verified savings. ButterflyX is our own app built on Xentient: a live showcase anyone can try, and a test bed that feeds the engine real outcomes. It will be free to start with optional subscriptions, but its job is to prove Xentient, not to be a second business.
MARKET
Source: Precedence Research, AI Inference-as-a-Service Market (2026). Enterprise GenAI spend separately tripled from $11.5B to $37B year-over-year (Menlo Ventures, via Hostinger LLM Statistics 2026), and 73% of enterprises now spend over $50K/year on LLM APIs (Kong Inc. survey, via Calliber). Xentient addresses the optimization layer sitting on top of this spend, not the whole market — even a small share of it is a large opportunity.
WHY NOT JUST USE AN EXISTING ROUTER?
Routing is real, and it's getting crowded — which validates the problem. OpenRouter and LiteLLM give excellent access to many models; Portkey is an enterprise gateway with routing, observability and governance (Portkey); Cursor and Factory run finely tuned routers inside their own coding products — Factory reports 63% lower cost at 99% of Claude Opus's pass rate (Factory, Sept 2026); and RouteLLM is open source (lm-sys). Each optimizes one layer of the stack, or one product. Nandromeda's thesis is different: make cost per successful task the primary objective — for any application, across providers — and prove it on the customer's own traffic. What compounds from that:
Knowing whether a cheaper answer was actually good enough is the hard part. Deterministic checks where possible (tests, schemas, exact answers), model-based judging only where needed, and escalation whenever confidence is low.
Every saving is measured against a baseline agreed with the customer, on their own traffic — and that same number is what pricing is based on.
Support, extraction, RAG, agents: what we learn about which models succeed at which kinds of work compounds across customers — shared as general patterns, never as customer data.
Data residency, approved providers, and stakes-based rules (e.g. legal tasks always escalate) are part of every plan, not an afterthought.
BUSINESS MODEL — directional, not finalized
The plan is a platform fee sized to the customer, plus — for larger deployments — a share of verified savings: measured against a baseline of what the customer was spending before Xentient, so the pitch is arithmetic, not a promise. If we save a customer real money, that's provable and the pricing conversation follows from the number, not the other way around. Nothing here is a signed term sheet — it's the shape we're building toward.
TRACTION & STAGE
Domain, brand and product direction are set. Heads-down on the core loop and a public benchmark, with pilots next. Raising a pre-seed round now (the ask is below) — and always glad to talk to investors thinking about this space early.
THE ASK
$900K on a SAFE — $7.5M cap
Introductions to early pilot customers, and investors who think about deep-tech / AI-infra efficiency plays are all useful right now — capital included, but not the only thing we're after at this stage.
Pre-seed SAFE, sized to where we actually are — pre-product, pre-revenue. Not a priced round, and not financial or legal advice; terms subject to counsel.
A plan, not a promise — allocations will be refined with our investors.
GET IN TOUCH
investors@nandromeda.comWe read every note personally. Want more than the deck? Ask and we'll share details directly.
Xentient connects to the models and tools your teams already use, then plans, supervises and verifies every task, so you pay for work that’s done right, and can show it.
API access is by pilot for now. Nothing here is a published result.
Most teams send every task to their most capable setup, whatever the task needs. The cost compounds quietly.
Results go out without a check tied to what the task actually required.
You see tokens and invoices, not what a successfully completed task costs.
Say what a good result looks like: a test, a schema, a rule set or a human review. Xentient works to that.
Each task is broken into steps, given only the resources it needs, and watched while it runs.
Every result is checked against its requirements. If it fails, the system revises the approach and tries again.
One number finance and engineering can both read: total cost ÷ tasks completed successfully.
Works with the models and tools you already use. Stakes and policies decide when a person must review.
Designed to run inside your environment, with what it learns kept private to you.
An illustration of how Xentient would run a large, high-stakes job: 4,200 invoices turned into a checked draft return for an accountant to review.
Xentient turns the request into a checkable definition of done, with the stakes and the deadline.
The job is split into eight steps, each given the lightest setup likely to pass.
Steps execute in order, adapting resources as the work unfolds.
Every result is checked. One step fails, so the system revises its approach and tries again.
What worked, what didn’t and what it cost is recorded for next month.
Later, Xentient will suggest changes, such as cleaning up duplicate suppliers first.
An illustration with made-up numbers to show the shape of the work. It is not a benchmark or tax advice; a qualified person signs off before anything is filed.
Send a task and what “done” means. Get back a verified result, plus the cost per successful task.
Building a product, cloud or platform? Build Xentient into it. Integrate, co-develop or resell with us.
Start with one workflow. Measure cost per successful task against your current setup.
Pilot slots are limited while we’re pre-seed.
Tell us what your teams run on AI today. We’ll tell you how Xentient can help.
// for developers
Xentient is an AI work optimization engine in front of your model calls. You define what “done” means — a test suite, a schema, an exact answer, a rubric — and it finds the most efficient path that meets it, verifies the result, and revises the approach only when it has to. Below is the current design, not a live API yet.
Describe a task, say what “done” means and how much is at stake — then watch the loop plan, run, verify and learn.
Illustrative simulation, not connected to a live model or real cost data.
Our consumer app is being built on the same engine you'll use: code requests are planned, run in a sandbox and checked before they reach the editor. Open the demo in code mode →
Every pillar points at one number: a successful task at the best price possible. Nothing here optimizes a proxy.
You say what success looks like — tests, schemas, exact answers or a rubric. Every decision is scored against it.
Deterministic checks first, model-based judging only where needed. Failing work never leaves — it’s re-planned and retried.
Model and provider choice, context trimming, caching, task splitting and timing — whichever combination makes this task pass for the least.
Every attempt is recorded with its cost and result, so the next plan for similar work starts smarter. Per customer, private by default.
PII, high-liability and ambiguous tasks escalate automatically; approved providers and data-residency rules are part of every plan.
If a provider is rate-limited or down, the task fails over to another path that meets the same bar.
This is the interface we're designing toward — not a published package yet.
Before today
# one model for everything — you pay for every attempt, right or wrong from anthropic import Anthropic client = Anthropic() response = client.messages.create(model="claude-opus-4", messages=[...])
After planned
# say what "done" means — Xentient finds the most efficient path that meets it from xentient import Xentient xt = Xentient(api_key="xt_...") result = xt.run( task="Extract the invoice fields", input=invoice_pdf, done=xt.schema(Invoice), # or xt.tests("pytest -q"), xt.exact(...), xt.judge(rubric) stakes="low", ) result.output # only returned if it passed result.cost # everything spent, retries included result.trace # the path it took: plan → run → verify → …
Honest status: this is the target interface — not installable yet. Join the list on the Xentient page to hear first when it is.
Intent is zero unnecessary retention of prompt content. A formal policy lands before general availability.
We do not hold SOC 2, HIPAA, or similar certifications yet — pre-launch. We won't claim them until real.
No published benchmark yet. We'll share measured numbers once we have pilot traffic.
Designed in from the start — a plan can always fall back to another provider that meets the same bar.
BUILT ON XENTIENT · COMING SOON
Everyday AI for everyone, with less wasted work.
Xentient insideButterflyX is our own everyday AI app, built on Xentient to show what it does: chat, write, study and code in one place. Xentient plans, runs and verifies every answer, so you get the same capable AI with less wasted work and a lower cost of getting things done. Start free; upgrade when you need more.
The demo runs in your browser: replies are pre-written, the code editor is real.
ButterflyX chat: every reply shows how Xentient ran the task, how it was checked, and whether it passed.
Emails, plans, summaries and ideas — in plain words, in your language.
Step-by-step explanations that check their own working before you see them.
Ask for code, then edit and run it right beside the chat — no setup.
Settings shows how much compute your answers used compared with sending everything to a large model, with the method one tap away.
Not just a chat box. When you ask for code, ButterflyX opens it in a mini IDE right beside the conversation — edit it, run it, see the console, and ask for fixes without leaving the app.
Students, parents, shop owners, writers, developers. The same capable AI, with less wasted work and a lower cost of getting things done.
Different people. Different work. One underlying intelligence.
AI should work smarter, not just harder.
You don’t need the biggest AI for every question. ButterflyX uses what the task actually needs.
Unnecessary work is avoided, repeated work can be reused, and simple tasks don’t have to take the long way around.
ButterflyX doesn’t just generate an answer and move on. Xentient checks whether the result actually meets the task.
The more you use it, the more Xentient can understand which approaches work for the kind of work you do.
Fewer unnecessary calls, retries and computations mean less wasted AI spend.
That’s the point. You ask. ButterflyX handles the work underneath.
Freemium with monthly subscriptions. Pricing will be announced at launch.
Chat, write & study · daily allowance
Higher limits · code mode + IDE · file uploads
Highest limits · deep mode · early features
Shared workspaces · admin & privacy controls · usage & efficiency reports
Today, ButterflyX runs on Xentient, optimizing how every task gets done across leading AI models. Tomorrow, it will also run Nandromeda’s own models, in ButterflyX, on other platforms, and for developers. Building a product? The same Xentient engine will be available to businesses through the Xentient API.
A share of ButterflyX profits will support water-restoration projects. We’ll publish where it goes.
ButterflyX is in development. Join the waitlist and we'll let you know when early access opens.
No spam — one note when early access opens.
Honest status: ButterflyX is in development and not yet released. The demo runs in your browser with pre-written replies; efficiency figures in Settings are estimates with the method shown.
Last updated: September 28, 2026
Heads up: Nandromeda is a pre-launch startup. This is a plain-language starting draft, not final legal advice — it should be reviewed by a lawyer familiar with Turkish (KVKK) and, if we take on customers elsewhere, EU (GDPR) data law.
We collect an email address (and a name or company, if you add one) only when you submit a waitlist, demo, contact or deck-request form. Those submissions are stored on our own web host and forwarded to our inbox, and are used only to reply to you or contact you about early access — never sold or shared. When you request the deck, your name and email are passed to EmailJS (our email-delivery provider) solely to send you that email — see their privacy policy at emailjs.com. To understand how the site is used, we run Umami, a privacy-focused analytics service: it sets no cookies, doesn't store your IP address, and records only anonymous visit data — the country and city your connection comes from, device and browser type, the site that referred you, the pages and pitch-deck slides viewed, and actions such as downloading the deck. You can switch it off with the banner's “Reject non-essential” button, and it's automatically off if your browser sends Do Not Track or Global Privacy Control.
Ask us to delete your email at any time via hello@nandromeda.com. GDPR/KVKK rights apply where relevant.
Figures shown on this site (cost savings, success rates, cost per successful task) are illustrative unless stated otherwise, and are not a guarantee of results. This site and any pre-release product are provided "as is" during early development. Governed by the laws of the Republic of Türkiye, pending formal incorporation and legal review.
We don't use cookies. We keep at most two small items in your browser's local storage: your cookie-banner choice and — only if you reject non-essential — a flag that switches analytics off. Neither is used for advertising or shared with anyone. Our analytics (Umami) is cookieless and stores nothing on your device.