Empromptu in the press
Read what journalists and publications are saying about Empromptu's AI application building platform.
Vibe Coding Is Dead: How to Actually Make AI Tools That Scale and Don't Break
Every enterprise leader has watched this film: a proof-of-concept that dazzles in the demo, then haemorrhages accuracy and chokes on edge cases three months in. Empromptu CEO Shanea Leven explains why it keeps happening — prompts tuned until a demo passes aren’t a system, and nothing in that process produces the evaluation, context management or governance a production workload needs. The alternative isn’t more prompting. It is building for reliability from day one: an accuracy bar set per use case, edge-case detection running continuously, and a model that learns from corrections instead of drifting away from them. That layer is what Empromptu builds.
Read articleEnterprises can now train custom AI models from production workflows, no ML team required
VentureBeat covers Empromptu's Alchemy launch. The piece names the structural reframe: enterprises stop renting intelligence from foundation models and start owning custom models trained by their own AI applications in production.
Read articleShanea Leven Named to Inc. Female Founder 100
Empromptu CEO Shanea Leven has been named to the 2026 Inc. Female Founders 500 for her leadership in redefining how enterprises move from AI prototypes to production systems.
Read articleTech Giants Split on How to Scale Agentic AI
Google and AWS take different routes to scaling agentic AI with real control and measurable performance, and PYMNTS sets Empromptu’s position alongside theirs: treat data preparation as part of the AI application, not a project that has to finish before it. Golden Pipelines sit between raw operational data and the AI features consuming it, so data arrives in a state an agent can safely act on. The payoff shows up in where teams spend their time — instead of hand-wrangling data and hoping, they validate outcomes, which is the only way agentic systems ever get trusted with anything that matters.
Read articleAI is giving the green IT movement another lifeline
IT Brew covers how AI infrastructure is reigniting the green IT conversation. Empromptu CEO Shanea Leven weighs in on the change-management piece, naming the citizen-developer wave and the energy waste that comes when builders don't know what their tools are actually doing under the hood.
Read articleThe 'last-mile' data problem is stalling enterprise agentic AI — 'golden pipelines' aim to fix it
Agentic AI keeps stalling on the last mile — the gap between data clean enough for a dashboard and data an agent can safely act on. Empromptu CEO Shanea Leven puts it plainly to VentureBeat: enterprise AI doesn’t break at the model layer, it breaks when messy data meets real users. Golden Pipelines are the answer — an automated layer that ingests from files, databases, APIs and unstructured documents, cleans and structures it, fills the gaps through labelling and enrichment, and applies audit trails and access rules as it goes. The part worth underlining is the evaluation loop: every transformation is logged and tied to downstream agent performance, so when a cleanup step actually makes the agent worse, the pipeline surfaces it instead of burying it.
Read articleGenerative AI Apps Need an Ecosystem, Not Just a Prompt
Most AI apps are built on vibes — tweak the prompt until the demo lands, then watch it fall over in production. Empromptu CEO Shanea Leven argues in The New Stack that reliable AI needs a whole engineering ecosystem around the model: evaluation that blocks regressions, context management that decides what the model should see, governance applied before deployment rather than after an incident, and retraining that turns corrections into improvement. None of that is a prompting problem, which is why no amount of prompt engineering fixes it. That ecosystem is what Empromptu ships, and why its applications keep working after the applause stops.
Read articleHow Anyone Can Build Meaningful AI Without Code - Ep. 283
Empromptu CEO Shanea Leven joins NVIDIA’s AI Podcast for episode 283 to argue that building meaningful AI shouldn’t require writing code — and to talk about what changes inside a company when the people who actually understand the work can build the tools for it themselves. The platform underneath that conversation is “AI that builds AI”, accelerated on NVIDIA CUDA, and the emphasis throughout is production-ready rather than demo-ready: applications that arrive evaluated, governed and fit to deploy, not prototypes that still need a platform team to finish. Forty minutes on why capability, not headcount, is the real constraint on enterprise AI.
Read articleEvery Al founder thinks they want a mega investing round. Trust me, you don't
Every AI founder thinks they want the mega round. Empromptu CEO Shanea Leven explains in Fast Company why it is a trap: big rounds push you toward optics instead of output. The argument comes from having done both — a $12 million round at CodeSee, then a deliberately small, oversubscribed pre-seed for Empromptu that investors competed for. Oversized early funding raises expectations faster than any company can earn them, and the discipline skipped in year one is exactly the discipline needed in year three. It is the same reason Empromptu would rather be measured on production accuracy than announcement volume.
Read articleEmpromptu: Seamless AI Integration for SaaS
A profile of what Empromptu does and, more to the point, what it doesn’t ask you to do. Most enterprise AI requires replacing systems that currently work; Empromptu adds AI application development and integration into the SaaS you already run. Modernisation happens in place — no eighteen-month rewrite, no parallel stack to maintain, no migration programme to fund. The software your teams already depend on becomes the thing that gets smarter, which is a far easier case to make internally than starting over.
Read articleEmpromptu: $2 Million Pre-Seed Closed To Build Self-Managing AI Context Engine For Enterprise Software
Pulse 2.0 covers Empromptu’s $2M pre-seed and the point of it: funding infrastructure that lets existing software modernise in place rather than be rewritten from scratch. The piece names the components that make that possible — Infinite Memory, the Adaptive Context Engine and Custom Data Models — which attack the same underlying problem from different angles: an application that remembers what it learned, decides which context matters for the task in front of it, and turns its own production decisions into a model the business owns. That is what “self-managing” means once you take the marketing out of it.
Read articleEmpromptu Announces $2M in Funding to Bring No-Code AI Application Development to Non-Technical Teams
AI Insider covers the $2M round and the background behind it: Empromptu’s founders came out of CodeSee and AI research, environments where reliability and compliance were never optional extras. That shows up in the product. You describe the application you need — a classifier, a recommendation engine, an internal workflow tool — and it gets built, evaluated and fine-tuned, rather than handed over as a prototype whose risk is now yours. The distinction matters more than the speed: plenty of tools can generate an app, far fewer can generate one you would put in front of a regulator.
Read articleEmpromptu Secures $2M Pre-Seed for Enterprise AI Apps
Launch
Read articleEmpromptu Raises $2M to Let Anyone Build Enterprise AI Apps
Tech Buzz frames the problem the way enterprise leaders experience it: how do you build AI applications without hiring an army of developers? Empromptu’s $2M pre-seed went toward that answer. The platform lets the people who understand a workflow describe it and get back something production-ready — evaluated, governed and integrated — instead of a demo that still needs a platform team to finish. Capability stops being a hiring problem, which is usually the real constraint rather than ambition or budget.
Read articleNo Code? No Problem: Empromptu Lets Founders Build AI Apps with Just a Prompt
A pickup of the $2M pre-seed focused on the part builders care about: getting a real AI application out of a prompt rather than a codebase. What the round funds is the infrastructure that makes such a claim survivable in production — evaluation, governance and context handling built in from the start, so what ships is something a business can run rather than a prototype whose risk is now yours.
Read articleEmpromptu Raises $2M in Pre-Seed Funding
FinSMEs’ funding brief captures the mission in a sentence: move enterprises from static SaaS to self-improving, AI-native applications. The operative word is self-improving. Most software improves on a release cycle, whenever someone finds time to act on what users struggled with. Empromptu’s systems manage, train and improve themselves while running in production — corrections become training signal, drift gets detected rather than discovered months later, and the application deployed in spring is measurably better by autumn without a project to make it so.
Read articleEmpromptu AI Raises $2 Million in Funding
The SaaS News covers the $2M pre-seed and where it goes: accelerating the Self-Managing Context Engine and the infrastructure behind self-learning enterprise applications. The ambition is specific. Empromptu wants the SaaS you already own to improve the more it is used — not through a roadmap you are waiting on, but because the system captures what happens in production and trains on it. Static software in an AI-native market is a liability, and this is the path off it that doesn’t require a rewrite.
Read articleEmpromptu raises $2M pre-seed to help enterprises build AI apps
TechCrunch leads with the claim Empromptu is happy to be held to: tell the platform what you want and it builds it. Dominic-Madori Davis also covers what the team carried over from building CodeSee — that reliability cannot be bolted on after a demo has earned its applause. Both halves matter. Generating an application quickly is now unremarkable; generating one with evaluation, governance and a path to a model you own is the part that decides whether it ever reaches production. The $2M pre-seed went into that second half.
Read articleIt’s not your imagination: AI seed startups are commanding higher valuations
TechCrunch looks at climbing AI seed valuations, and Empromptu CEO Shanea Leven names the reset point: Cursor’s run to $100 million in revenue in twelve months. She adds a data point of her own — as a second-time founder, her startup’s valuation at this stage is double what her first commanded at the same point. The market is paying for AI that ships, not AI that demos. That is worth taking seriously whether you are building or buying: the bar for what counts as working software has moved, and it has moved toward production.
Read articleHow AI Is Opening Opportunities for Women in Tech
TechChannel looks at how AI and remote work are opening paths in tech as human-centred skills gain value. Empromptu CEO Shanea Leven offers measured optimism with one caution: in this gold rush, everyone is trying to sell shovels. The tools that genuinely hold up are the ones that survive real work, not the ones with the best launch video — a test she would apply to Empromptu as readily as anyone else, which is why the company would rather be judged on accuracy in production than on how fast something can be prototyped.
Read articleWomen Driving Tech 2026
TechChannel’s Women Driving Tech Forward e-book profiles twelve women shaping the future of the IBM Z and Power communities, recognised for their leadership, their work on hard technical problems and their commitment to innovation. Empromptu CEO Shanea Leven is among the contributors, alongside engineers and executives from Broadcom, BMC, Dell, Fortra, Lightedge and CM First Group. The collection asks each of them for the practical version of how they got there, and for a read on how the current wave of transformation is opening routes into enterprise infrastructure for the people who follow them.
Read articleAn architecture for engineering AI context
InfoWorld covers the architecture behind something widely misdiagnosed: the context problem was never about window size, it is about deciding what matters right now. A system that can hold a million tokens but has no judgement about which of them to use is slower, more expensive and no more accurate. Empromptu’s answer is two infrastructure primitives — Infinite Memory, so an application retains what it learned across sessions, and the Adaptive Context Engine, which selects what to surface for the action in front of it. Together they mean applications stop re-reading everything and start acting on the right thing.
Read article10 Major AI Companies You Should Know
Kiplinger maps the ten companies driving the AI buildout, with Empromptu CEO Shanea Leven weighing in on Google’s unusual position — strong in both model development and training data, which is rarer than it sounds — and on what happens when AI is pointed at one high-stakes domain rather than everything at once. That second point is the more useful one for enterprises. General-purpose capability is impressive, but durable value tends to show up when a system is narrowed to a specific, consequential workflow and held to a measurable accuracy bar.
Read articleVibe coding is killing open source, increasing software risk
TechTarget examines how vibe coding is straining the open source it depends on, and Empromptu CEO Shanea Leven names the asymmetry: consumption keeps rising while the human layer around those projects thins out. She adds the part that rarely gets said — nobody ever solved paying maintainers, and AI-generated consumption widens that gap rather than closing it. For anyone running AI-assisted development at scale this is a supply-chain risk, not a philosophical one, and a strong argument for knowing exactly what your systems depend on — the kind of visibility Empromptu’s governance layer is built to give.
Read articleShanea Leven, Founder and CEO at Empromptu AI – Interview Series
A conversation with Empromptu CEO Shanea Leven covering the path here — building developer platforms at major technology companies, founding CodeSee and its acquisition by GitKraken in 2024, and then Empromptu. The thread running through all of it is the same: developers and enterprises keep being handed tools that look impressive and fall over under real load. Empromptu builds the unglamorous layer underneath — evaluation, context, governance, model ownership — that decides whether AI survives contact with production.
Read articleTrue multi-agent collaboration doesn’t work
CIO reports what Empromptu has been seeing too: individual agents can be highly reliable, and the moment you group them they fail quietly. Shanea Leven offers the prescription the platform is built on — let each agent deliver against a specification and keep a thin orchestration layer to assemble the results, rather than hoping agents will coordinate themselves. The failure mode in multi-agent systems is almost never a single bad output; it is coordination collapsing under complexity while every individual component still reports success. Structure beats autonomy, which is why Empromptu’s orchestration is deliberately boring and deliberately observable.
Read articleAI is a skills challenge—one that can be addressed
IT Brew frames AI adoption as a skills challenge rather than a technology one. Empromptu CEO Shanea Leven points at what the market is already doing in response: experts leaving to consult on closing the gap, which prices capability out of reach for most teams. The more durable answer is to put the expertise into the platform. Empromptu handles the parts that normally demand a specialist — data preparation, evaluation, governance, retraining — so the people who understand the workflow can build against it directly, and capability stops depending on who you managed to hire.
Read articleShanea Leven Of Empromptu On Pushing the Boundaries of AI
A long-form Authority Magazine interview with Empromptu CEO Shanea Leven, built around a tension every enterprise eventually hits: AI systems are probabilistic, and businesses require deterministic outcomes. A model that performs well 95% of the time sounds impressive until you work somewhere regulated, where the remaining 5% is the entire conversation and a single hallucinated answer carries real business risk. Her response was to stop waiting on better models and build infrastructure around them — evaluation systems, governance layers, human approval flows and edge-case detection as core parts of the platform rather than bolt-ons. The line that lands: the future of AI is not just better models, it is better systems around the models. The interview also names where the opportunity sits — nearly everyone is focused on generation, and almost nobody on what happens after deployment.
Read articleEmpromptu Launches Alchemy Models: The Next Wave of AI After Vibe Coding
“Right now, most companies are renting intelligence.” That is the line Empromptu led with in announcing Alchemy Models, and this pickup carries the mechanism behind it: a phased path from the AI applications a company already runs to a custom model it owns. You build the application; the platform captures the decisions, corrections and edge cases that application produces; then it trains on them. No dataset to assemble up front, no fine-tuning project to staff — the model is a by-product of work already under way, and it keeps improving for as long as the application keeps running.
Read articleReal-time Analytics News for the Week Ending May 16
RT Insights picks up Alchemy Models in its weekly round-up, and the one-line summary is the pitch: create, train and deploy your own production models by building the AI applications you were already going to build. The sequencing is the point. Most enterprises are told to assemble a dataset first and earn a model later, which is why so many AI programmes stall before anything reaches production. Empromptu inverts it — ship the application, let it generate the signal, and the custom model arrives as an output rather than a prerequisite.
Read articleEmpromptu Launches Alchemy Models: The Next Wave of AI After Vibe Coding
SD Times frames Alchemy Models as what comes after vibe coding, which is the right frame — prompting your way to a demo is now easy, and what follows is the hard part. Alchemy lets a company create, train and deploy its own production models out of the AI applications it is already building, with training data collected automatically from real usage and experts labelling the edge cases. The reason it matters: enterprises already hold the subject-matter expertise a good model needs but not the AI talent to capture it, so they hand their most valuable data to a model provider instead. In Empromptu’s internal benchmarks the resulting custom models cut inference costs 40-80% and lifted accuracy 25-30%.
Read articleEmpromptu AI’s Alchemy Models Turn Enterprise Workflows Into Self-Improving AI-Without Fine-Tuning Hassles
This pickup of the Alchemy Models launch goes straight to the question enterprises ask: can workflows already running become self-improving AI without a fine-tuning project? That is the design. Training data is collected automatically as the application runs, experts label the edge cases, and the model that comes out belongs to the business — no ML team, no data-science detour, no eighteen-month programme to fund. In Empromptu’s internal benchmarks those custom models reduced inference costs by 40-80% and improved accuracy by 25-30%.
Read articleMusk Takes the Stand: ‘I Was a Fool’ to Fund OpenAI Charity
Techstrong.AI covers the Musk–OpenAI trial, with Empromptu CEO Shanea Leven on why it matters beyond the courtroom theatre: it could be a preview of the next decade of AI, because what is really being litigated is who owns the models and on whose terms. That isn’t abstract for enterprises. If your products depend on a provider whose governance, pricing and ownership structure can be rewritten by a court, you have taken on a dependency you cannot hedge — one more argument for keeping the intelligence that matters inside your own environment.
Read articleEnterprise AI Is Failing in Production — Empromptu AI Is Fixing the Foundation | TFiR
TFiR sits down with Empromptu CEO Shanea Leven on where enterprise AI actually fails — not in the demo, but in production, against messy data, non-compliant workflows and model behaviour that shifts without warning. The conversation covers the answer end to end: Golden Pipelines to get operational data into a state an AI system can act on, governance controls applied at build time, and custom model training that turns production decisions into a model the business owns. The reason it is one platform rather than four tools is that these failures compound — fixing the data without fixing evaluation just relocates the problem downstream.
Read articleSeed-Stage AI Startups Are Flashing Record Revenue Numbers And Most Of Them Are Not What They Seem
Forbes examines the record revenue numbers coming out of seed-stage AI startups and concludes most of them are not what they appear to be. Empromptu CEO Shanea Leven is quoted on the expectations that come with those numbers: when the market rewards a revenue headline, the pressure lands on founders to produce one regardless of what sits underneath it. The durable version of this business is less photogenic — accuracy you can measure in production, systems that survive a real workload, customers who renew because the thing works. That is the standard Empromptu would rather be held to.
Read articleAnthropic Accidentally Exposes Claude Code's Code
Asked why AI seed valuations have climbed so far so fast, Empromptu CEO Shanea Leven points to the data point that reset the market: Cursor reaching $100 million in revenue inside twelve months. That number changed what investors believe is possible and, more usefully, what buyers now expect. Enterprise AI is no longer judged on a convincing demo; it is judged on what survives contact with production — a healthier standard, and the one Empromptu builds to.
Read articleAI extinction talk: IT leaders weigh in
TechTarget asked IT leaders whether AI extinction talk changes how they govern AI. Empromptu CEO Shanea Leven gave the unglamorous answer: it doesn’t, and that’s the point. The risk that shows up in production isn’t a model turning on humanity — it’s the accumulation of systems nobody scoped, approved or monitored. The governance question worth asking is narrower and far more useful: what is this AI allowed to do, what data can it reach, and could you prove either to an auditor six months from now? That is the question Empromptu’s platform is built to answer, with policy and permissions attached at build time rather than retrofitted after something has already gone wrong.
Read articleAmazon Urges Rigorous AI Testing, Rejects Calls for Industry Slowdown
Techstrong covers Amazon’s case for rigorous AI testing over an industry slowdown. Empromptu CEO Shanea Leven points to what enterprises are already doing while that debate plays out: moving to smaller, open-weight models so they can own more of the stack, keep sensitive data inside their own infrastructure, and train on proprietary data instead of handing it to someone else’s model. That shift is the premise Empromptu is built on. If the intelligence is going to live in your business, the weights and the training loop should live there too. Testing matters; owning what you tested matters more.
Read articleWhy Healthcare AI Demands an Owned Intelligence Layer
Empromptu CEO Shanea Leven argues in HIT Consultant that healthcare is where rented AI breaks down fastest: the compliance maths never works once PHI has to leave your environment for a model you don’t control. The piece sets out three requirements — normalise the data before anything touches it, apply governance at build time instead of auditing after deployment, and own the model so the intelligence clinicians generate compounds for the provider rather than a vendor. That is the architecture Empromptu ships: it runs inside your environment, detects and redacts PHI before a model sees it, and trains a model that stays on your side of the line.
Read articleEmpromptu launches AI software to reduce GPU power spikes
Datacenter Dynamics covers Empromptu’s Grid Guard launch, and the headline number is worth repeating: early deployments cut power volatility by roughly 80% without materially slowing the AI workloads causing it. Dense GPU clusters draw power in sharp, unpredictable swings, enough to threaten the electrical infrastructure of the facility running them. The usual remedy is to throttle training, which nobody wants. Grid Guard smooths demand at the workload level instead, so throughput holds and the facility keeps its margins. It is a fair illustration of how Empromptu approaches AI infrastructure generally: the binding constraint is rarely the model, it’s everything around it.
Read articleOwning The Intelligence Your Company Creates
A conversation with Empromptu CEO Shanea Leven about the gap every team hits: the prototype demos beautifully, then production arrives. She walks through where it opens — accuracy that drifts once real inputs show up, edge cases nobody wrote a test for, outputs that shift without anyone noticing — and the practical response: set an accuracy bar per use case rather than chase one headline number, and treat edge-case detection as a first-class system rather than a bug queue. That is what Empromptu’s evaluation and optimisation layer does continuously, which is why “it works” and “it’s reliable” stop being two separate milestones.
Read articleEnterprises are not building AI advantage. They are leasing it.
Empromptu CEO Shanea Leven makes the case in TechRadar Pro that enterprises aren’t building AI advantage, they’re leasing it. If the advantage lives inside somebody else’s model, every correction your team makes, every edge case you solve and every piece of domain expertise you encode improves a model your competitors can rent tomorrow. The alternative isn’t building a foundation model from scratch — it’s owning the layer that differentiates you: a custom model trained by your own workflows, running in your own environment, improving on your own data. That’s the difference between an operating expense and an asset you hold, and it’s what Empromptu exists to deliver.
Read articleThe AI Breakthrough Playbook: 100 Habits From Entrepreneurs Pushing the Boundaries of AI
Authority Magazine collected habits from twenty AI founders, and Empromptu CEO Shanea Leven used her five to press one argument: most companies are unknowingly training an external provider’s model with their own proprietary workflows and business knowledge. Competitive advantage comes from intelligence that compounds inside the organisation instead. The part that surprises people is the cost — hyperscaler budgets aren’t required. A company building an expert small language model for one specific thing, accounting or healthcare, doesn’t need AGI-scale training to reach high accuracy, and plenty of businesses sit on five, fifteen or fifty years of expert data they have never harnessed. Her other habits follow from it: most AI failures are data failures, not model failures, and the companies succeeding build evaluation, governance and monitoring around the model instead of waiting for a better one.
Read articleMoney Is the Only Customer Validation That Matters
Fund Build Scale puts the uncomfortable question to Empromptu CEO Shanea Leven: what actually counts as validation? Her answer is that customer enthusiasm isn’t it — customers will tell you whatever they want to tell you, and the only signal that holds is someone putting a credit card down or signing a contract with real money attached. The conversation traces how that discipline shaped the product. Empromptu set out to optimise existing AI systems, until customer after customer said they had nothing to optimise yet and asked for an accurate one built from scratch. Ten engagements later the pattern was obvious: they all needed the same infrastructure. Building that infrastructure, then generating applications on top of it, became the platform.
Read article✨ Today's Featured AI Tools In One Sentence (June 04, 2026)
A round-up of ten AI tools with Empromptu among them, described in a single line worth keeping: train fine-tuned models with the AI apps you’re already building. That is the shortest version of the whole thesis. No separate data programme and no ML hire are needed to end up with a custom model — the work a team is already doing becomes the training signal, and the model that comes out belongs to the business.
Read articleResearcher “gave Claude Code ‘ADHD’… and it thinks 2x better now.” Outside experts want more proof.
The New Stack went looking for outside scrutiny of a claim that a context trick made Claude Code reason twice as well, and Empromptu co-founder and CTO Sean Robinson gave the honest read: it isn’t strictly new as an agent pattern, and the benchmark needs more testing before anyone builds on it. Asking for evidence rather than generating headlines is the instinct built into the product — every change runs through evaluation before it ships, because in enterprise AI the gap between a promising result and a dependable one is the only thing that matters.
Read articleInternational Women's Day 2026: Industry Leaders Share Insights on Women in Technology and Innovation
VMblog gathers industry leaders for International Women’s Day 2026, and Empromptu CEO Shanea Leven starts from influence rather than fairness: the AI systems shaping the world are being built right now, and the voices in the room decide whose problems get solved, whose data is represented and whose safety gets prioritised. The numbers make the stakes concrete — women are more than 40% of the global workforce, under 30% of senior leaders, and around 14% in STEM. There is no silver bullet. It takes sustained effort across an organisation with real backing from the top, a harder commitment than a single day of posts and a far better predictor of what actually changes.
Read articleComputer science degrees may be losing their charm, but tech leaders aren't worried
IT Brew asks whether a computer science degree still pays off, and Empromptu CEO Shanea Leven points at where the expertise is quietly going: experts leaving to consult on the skills gap, which puts capability out of reach for most teams. The more durable fix is to move that expertise into the platform. If data preparation, evaluation, governance and retraining are handled by the system, building production AI stops depending on whether you won a hiring race — and the people who actually understand your business get to build against it directly.
Read articleClaude Cowork Is a Productivity Test Enterprises May Fail
Reworked asks the question every enterprise is about to face: when an agent organises files and writes reports unsupervised, who is accountable when it gets something wrong? Empromptu CEO Shanea Leven draws the line precisely — once an agent modifies systems rather than answering questions, the failure mode stops being “the answer was wrong” and becomes “the system quietly changed reality.” That is a different class of risk needing different controls: permissions scoped at build time, every decision logged, and a human override that genuinely works. Convenience and responsibility are not the same purchase.
Read articleThe buzzy new AI trying to go from chatbot to full-on coworker
Quartz covers the first genuinely mainstream agentic assistant, with Empromptu CEO Shanea Leven describing plainly what it does: reads files, moves documents, cleans inboxes, writes and runs its own code. She calls it impressive, because it is — and then names what follows. The moment an agent takes actions instead of producing answers, enterprises need controls and audit trails around it, not just access to it. That is the gap between a tool individuals love and a system a regulated business can deploy, and closing it is most of what Empromptu builds.
Read articleFOD#132: What to Expect in 2026?
Turing Post’s 2026 outlook includes Empromptu CEO Shanea Leven’s blunt framing: 2023 to 2025 were about demos. What comes next is a UX shift — AI stops asking you to repeat yourself and starts anticipating what you need. The catch is that anticipation is a memory problem before it is an interface problem. A system cannot predict what you need if it forgets what you did last week, which is why Empromptu treats persistent memory and adaptive context as infrastructure. The interface change follows from the plumbing, not the other way round.
Read article139 WorkTech Predictions from Industry Experts for 2026
Solutions Review collects 139 WorkTech predictions for 2026, and Empromptu CEO Shanea Leven’s runs under a heading worth standing behind all year: the AI hype bubble pops, the reliability era begins. 2023 to 2025 were about demos; 2026 is about production accuracy, and enterprises will stop paying for magic moments and start demanding systems that run at 95%+ reliability. She makes a second point buyers will recognise — features don’t close deals any more, confidence does. The sellers who win aren’t the ones with the best deck, they’re the ones who can transfer certainty that this will work in production. Building the evidence for that claim is the entire job.
Read article50+ Expert Predictions: Ways to Drive Agentic AI, Data Governance, and Security in 2026
Star CIO gathers 2026 predictions from more than fifty experts, and Empromptu CEO Shanea Leven’s is about expectations rather than technology: consumers will come to expect AI that remembers everything. That sounds like a consumer story, but it resets the enterprise baseline. Once people are used to systems that carry context between sessions, an internal tool that forgets every time reads as broken. Memory and context stop being features and become table stakes — which is exactly why Empromptu built Infinite Memory and the Adaptive Context Engine as infrastructure rather than add-ons.
Read article5 VCs sounds off on the AI question du jour
Fortune’s Term Sheet puts the bubble question to five VCs and notes Empromptu’s $2M pre-seed in the same issue — raised to help enterprises turn the SaaS products they already own into AI-native systems. That is the work most likely to outlast whatever this cycle turns out to be. Bubble or not, the companies left holding durable AI advantage will be the ones who owned their models and their data instead of renting both, and who measured accuracy in production instead of quality in a demo.
Read articleJoe Lonsdale Backs 'Bob the Builder' AI Startup for Contractors
The Wall Street Journal’s Pro venture newsletter notes Empromptu’s $2 million pre-seed, led by Precursor Ventures, in its funding round-up — a San Francisco startup focused on AI implementation. Implementation is the operative word and the reason the round exists. The gap in enterprise AI stopped being access to models a while ago; it is now everything required to put one into production safely — normalised data, evaluation that holds up, governance applied before deployment, and a model the business actually owns at the end of it.
Read articleAI: OpenAI on the backfoot vs Google Gemini 3. RTZ #917
A newsletter on Gemini 3 putting OpenAI on the back foot, with a caveat from Empromptu CEO Shanea Leven worth keeping: when Gemini doesn’t know something, she finds it more willing than ChatGPT-5 to hallucinate an answer. That is not a verdict on either model — it is the reason model choice is never the whole answer. What you build around a model decides whether its output can be trusted: evaluation that catches confident nonsense, context that gives it the right material, and a measurable accuracy bar per use case. Swapping providers doesn’t fix a missing system.
Read articleOpenAI faces its toughest challenger yet
Axios covers Gemini 3 Pro forcing a reckoning at OpenAI, with Empromptu CEO Shanea Leven on what it means: Google is unmatched at the data it can train on — a structural advantage, and not one you can out-raise. She adds the caveat that matters more to anyone shipping on these models. When Gemini doesn’t know something, she finds it more willing than ChatGPT-5 to hallucinate an answer. Neither point is a verdict on a model; both are an argument for owning the layer around it — evaluation that catches confident nonsense, context that supplies the right material, and an accuracy bar set per use case. Switching providers doesn’t fix a missing system.
Read article💸 Carmen Palacios-Berraquero's Nu Quantum Raises $60M Series A
Launch
Read article