Startup Spotlight

TL;DR

• Community and entrepreneurship is one of Berkeley RDI's three core pillars. This spring RDI ran the Berkeley Xcelerator spring cohort with eight early-stage companies spanning the agentic AI full stack; four more early-stage industry companies joined them here, for twelve presentations in total.
• The two most crowded lanes are context and access control. cognee and Headroom are both selling "stop stuffing garbage into the context window." AgntID and ArmorIQ independently argue that passing authentication doesn't mean being aligned, and both compare the agent's stated intent or plan against what it is actually about to do — at runtime.
• The OpenAI / Hugging Face incident has become a shared market anchor for agent-security products; AgntID cited it directly as a failure mode its product would have caught.
• "Don't wait for the API" is the other through-line. Narada AI and H Company both argue enterprise work is fragmented by design, and that rather than waiting for every workflow to be rebuilt around APIs, agents should drive the existing interface layer directly — including legacy green screens, Citrix, and remote desktops.
• The session closed the summit, followed by a poster session and reception in the MLK building.

The Twelve

1. Narada AI (~03:01:32–03:10:30)

Dave Park (CEO and co-founder; started his first company, Coverity, out of his Stanford CS PhD) presented an agentic automation platform purpose-built for enterprise applications and workflows. The premise, drawn from hundreds of customer meetings: what's still manual in HR, IT, and finance isn't copilot-shaped work but long-horizon processes — ERP testing, data validation and reconciliation across silos, order/invoice/bill reconciliation — spanning legacy applications, SaaS portals, and the web. Because APIs are limited for many steps, the work requires operating through the UI: reasoning visually about what's on screen, then clicking, typing, scrolling. Hard-coded scripts and bots break whenever an interface changes; general-purpose models eventually hallucinate against the real exceptions of messy production environments (login issues, dropped connections, timeouts, configuration changes, duplicate CRM records that all qualify).

Three responses: (1) proprietary techniques that automatically map a customer's application and interface configurations, generating agents on the fly from a natural-language process description or even a screen recording; (2) turning their learnings about where and why agents fail into curated test environments and synthetic data, used to develop harnesses that recover from real-world exceptions; (3) an agentic planning and execution framework from their own research, the LLM Compiler, which decomposes long-horizon tasks into granular steps with unit testing, exception handling, guardrails, and self-healing at each one. The same mapping machinery also optimizes high-volume workloads: once the execution path through an interface is learned, the next thousands of orders or claims run with far less compute at higher speed and accuracy. The team includes UC Berkeley's Kurt Keutzer and Amir Gholami, who led the research behind Narada at the UC Berkeley AI lab. Examples: speccing competitor car models, options, and pricing across 23 countries (hundreds of steps per task); a customer with 4,000 billing portals with no API support. They deliver free PoCs within days.

2. cognee (~03:10:39–03:15:55)

Founder Vasilije ("Vess," in from Berlin) presented an open-source AI memory layer. He framed the problem as: can we add a self-improvement loop to any harness and any model without token maxing? — and insisted it is a data problem, not an agentic one. Agents produce a hundred times more data than humans, agentic workflows are data-intense and generate enormous context, and meanwhile the traditional systems, CRMs, and data silos also need to be connected and reasoned over.

cognee sits between your data and your agentic workflows, ingesting, structuring, and processing data into combined graph and vector representations — he likens it to lasagna, layering meanings on top of each other, cross-connecting them, and constantly evolving them. The properties it has to handle: versioning, temporality, concurrent reads and writes by different agents with different memories, conflict resolution, timestamps, and meta-representations of what something meant at a given point in time. His illustration is pronoun resolution ("him" refers to different people on different days), extended to business terms whose definitions drift — revenue, fiscal year. Architecturally it runs on Postgres, and each agent, team, or tenant can have its own database, all supported in the open source. There's a Claude Code plugin, an API and CLI, and Rust, TypeScript, and Java versions; run it as a server to share data between agents, users, and teams. Numbers: GitHub stars up from roughly 10,000 to 30,000 since the start of the year, around 8 million SDK runs a month and roughly 170–180,000 downloads last month, top scores on a standard memory benchmark, and 86% token savings versus context stuffing.

3. Nimblemind (~03:16:01–03:22:00)

The co-founder and CEO presented AI agents for healthcare, opening on capacity and administrative cost: there are not enough clinicians and trained staff to see and treat everyone, and in the US alone administrative tasks — work not aligned to actually delivering care — account for about 25% of spending, roughly $600 billion to $1 trillion. Healthcare has also grown far more complex than the one-to-one doctor–patient relationship of fifty or sixty years ago: care pathways, genetics and lifestyle, plus billing systems, coding, and payer authorizations.

His diagnosis of why copilots and LLMs dropped into these workflows fall short: they miss three ingredients — predictable, structured, consistent task execution; systematic human-in-the-loop that exposes low-confidence decisions to experts when appropriate; and objective-driven workflows. Nimblemind combines all three to automate what he calls end-to-end healthcare knowledge work: find the relevant information across the myriad systems inside a provider, understand context and exceptions, complete the multi-step workflow while flagging what needs a human, and return a traceable output. The technical bet is specialty-specific small models — oncology, pathology, radiology, nephrology and more — combined into a system of experts, matching how healthcare is actually practiced. Their case study, a paper with SingHealth: scanning over two million pathology reports for missed cases of H. pylori and gastritis. A human would need roughly 82 hours per 10,000 reports; Nimblemind saved over 99% of the time, at accuracy well above the internal acceptability threshold, and delivered it in under a week. The company is about two and a half years old, venture-backed, with around 100 customers worldwide, scalable APIs, white-labeling for health tech companies, and a new feature letting non-technical users at providers build and ship their own workflows.

4. AgntID (~03:22:12–03:27:18)

A third-time founder (his last cybersecurity startup was acquired by Fortinet; previously a distinguished engineer) presented runtime access control for AI agents. His deliberately oversimplified opening example: the prompt is "summarize Google Doc A." The agent should only look at doc A — if it gets overeager and starts reading doc B, block it. The intent was to read — if it starts updating or deleting, block that too. You said Google Docs — if it makes a tool call into Dropbox, block it.

Why the problem exists at all: before agents, applications had fixed workflows and known tools, so all access was predefined at design time. The whole point of using agents is that they reason and decide the next action dynamically, discovering tools at runtime via MCP and other protocols — so access has to be evaluated during execution. AgntID's product provides just-for-task runtime access: only the access needed for this task, only while it's needed, only at runtime, so agents never receive blanket permissions. It narrows in two stages — intent evaluation (block anything outside what the agent is trying to do) then policy evaluation (customer-written policies) — and can finish with scoped credential derivation, a token exchange yielding a smaller token the agent then uses for its MCP or CLI call. The runtime deploys inside the customer's own environment, sandwiched between agents and MCP/tools, so customer data stays private and latency stays low. He invoked the OpenAI / Hugging Face incident directly: a much more complicated example with multiple points of failure, but an unauthorized tool call was one of them, and that part AgntID could have stopped. Positioning: sold to infrastructure buyers — identity, security, DevOps — with very little developer dependency, bring-your-own MCP/CLI/skills (no catalog of their own), and complementary to existing IAM, IGA, and agent orchestration systems like LangGraph and Vertex AI. Available since March 2026, pre-seed, with large enterprise customers. His close: "The future of software is agentic. And because it's agentic, the future of access control is runtime."

5. RELAI (~03:27:23–03:33:08)

Soheil Feizi (founder and chief scientist; associate professor of computer science at the University of Maryland) presented Verifiable Continual Learning (VCL). The goal of continual learning is to keep improving an agent from its own experience without regression, and that improvement can happen in the model layer, the harness layer, or the memory layer. He dismissed both current approaches: manual inspection — you see a failure and ask a coding agent to change the target agent — is "vibe-based," and it's unclear whether the change is effective or whether it created hidden regressions on other samples; prompt or harness optimizers only apply when you have benchmarks rather than real logs from the agent, and are prone to shortcut learning and overfitting.

RELAI's engine has three stages: (1) turn every signal from agent behavior into replayable learning environments that simulate and evaluate those behaviors — "this becomes the foundation of verification, because now everything becomes testable"; (2) run holistic root cause analysis to find the smallest durable change; (3) hand that to a lifelong agent optimizer with in-loop regression control, improving the agent without creating regressions, efficiently enough that the loop can run frequently. In practice it's a few commands: initialize inside your agent repo and it scans the repo and creates a learning harness (a one-time job); one command creates a rich learning environment from a described scenario or a failed log with feedback, including learning personas, mocked tools, and verifiers/evaluators; then optimize with a rollout budget improves the agent and opens a pull request showing the changes and the reasons for them across harness, memory, and other aspects. His demo scenario: a customer support agent facing an adversarial user in a multi-turn conversation pushing for an unauthorized refund. For systematic evaluation they built a continual-learning version of Terminal-Bench in two phases — 12 hard tasks, then 10 — to test whether optimizers compound. Meta-harness and GA methods improve slightly over baseline, but on inspection they either stop improving or show negative transfer from phase one to phase two; RELAI shows significant improvement over both the baseline and those methods. "Every failure becomes a test, every change is measured, and every improvement is verified." Available today at relai.ai, with an RDI 2026 promo code good for $500 in credits.

6. Headroom (~03:33:15–03:38:14)

The founder of Headroom Labs (previously at Netflix on recommendation infrastructure) opened with the positioning line: "Agents don't have a reasoning problem. They have a context problem." The origin story: debugging GPU problems with Claude Code, they found 90% of the context was spent reading garbage that wasn't important to the prompt — which convinced them that the way context gets filled with data today is fundamentally broken.

Headroom is a local proxy — pip install a package and it runs on your laptop. When you use Claude Code, Codex, Cursor, or any agentic harness, it inspects all data before it reaches the model and removes the bloat, detecting whether what's flowing through is JSON, code, or flat text. The differentiator is that the compression is reversible: it squashes something but leaves a breadcrumb, telling the LLM that if it needs the original, here is a tool call it can make — which preserves accuracy while still delivering large savings. Results: about 15% token compression on coding agents and 60% on data agents, benchmarked against SWE-bench and others across code search, debugging, and triaging a codebase, with almost no accuracy loss. Usage is headroom wrap claude. Traction: seven months from first release, the number one GitHub repository last month and this month, 64,000 GitHub stars, 2 million+ developers, and 250+ active contributors; he attributes the June 1st hockey stick to a culmination of factors, mostly companies realizing that token maxing is no longer important — it's all about value maxing. Compression is only the wedge; the goal is context intelligence — letting one agent's context be picked up and operated on by a new agent. Today that's done with markdown files, and they want to replace that primitive with an open spec for context management between agents, which would enable knowledge graphs, governance, and provenance. "As agents scale, context is the bottleneck, and we are the layer that makes it efficient."

7. Founding Dev (~03:38:35–03:42:45)

Talha (second-time founder; raised $2.7M for his last company and worked with 100+ businesses including GitLab and Scale AI) pitched replacing expensive, bloated SaaS subscriptions with a company's own tools. His number: businesses spend $200,000 per year renting software — and he means small mom-and-pop shops, not large enterprises, which spend millions. Founding Dev is a single platform to build and replace those subscriptions at 70% lower cost, to build any internal dashboards, and — most importantly to him — to run the business as an operating system.

The gap versus generic code builders: those are fine for small software, but not for compliance-grade SaaS tools (e-signing, HR workflows, Salesforce- or HubSpot-class systems), and even if you build something, the software lifecycle, deployment, and ongoing management are hard to carry. His customer example is Johanna, an education consultant in Utah, previously spending $135,000 a year on SaaS subscriptions, dev shops for internal tools, and the same dev shops for integrations between them. Now she gets one platform to build, deploy, and manage everything, never worries about deployment, uptime, or lifecycle, and — with all her company knowledge assembled in one place — even creates customer videos from inside the platform. She saved 70%, put it into marketing, and recently closed 30 new school districts. Pricing runs $2,000–$7,000 per month depending on usage and number of tools. Profitable since day one, close to $500K ARR, adding roughly $100K in ARR per month.

8. ArmorIQ (~03:42:49–03:48:05)

A second-time founder opened with the thesis: having an identity and passing authentication doesn't mean you're aligned. Every agent running in production today has some identity — a login or identity rails, and it has probably passed some security checks — and yet agents still take actions they were not allowed to take. Meanwhile agents are moving from simple tasks to complex long-running work: making tool calls and API calls, spawning sub-agents, orchestrating other agents, even executing commerce transactions that move assets. The whole security ecosystem still rests on authentication as its single organizing principle.

So he reframes the question: not "is the agent authenticated?" but "why are my agents taking the actions they are taking?" They call the answer intent governance, as distinct from identity governance, which in his view is essentially a solved problem. Architecturally, ArmorIQ is an adaptive runtime control layer sitting between the agent, the LLMs, the policy systems, and the surfaces it acts on. On the agent side it interfaces with standard frameworks (LangChain, Langfuse), captures the agent's plan, and matches that plan against the policies the agents run under; if the plan violates a policy, the action is stopped before it touches a surface — an MCP gateway, an API, a CLI tool, or other sub-agents. The vision is explicitly not "another lock for the same door" but a separate substrate he calls an intent assurance protocol, covering not just the intent but every subsequent action the agent takes. The product launched about four months ago, with roughly 26,000 developers on the platform and enterprise customers including Intuit.

9. Keenable AI (~03:48:17–03:53:28)

The founder — previously CEO of Yandex Search, with a co-founder who was the main scientist behind Amazon web search ("this is our third search engine") — presented web search and a web query language for AI. His framing observation is sharp: ask AI any random question and the answer is perfect; ask a question you actually understand deeply and the answer is average. Not wrong — average. His favorite demo question is "what is the best search API?", which returns a beautiful table with use cases, a clear winner, and justification: "it looks like this AI just went to business school," because what's missing is benchmarks and data — it's an absolutely ungrounded and absolutely confident recommendation. The cause is that LLMs are excellent summarization machines trained on exactly that kind of content, so for each nuanced topic the result regresses to average.

The fix is that models should search far more at runtime and during training, then reason over what they find. The bottleneck is economics: ChatGPT makes roughly one query per three messages — about one search query per 5,000 generated tokens, or 20 cents per dollar — and it's slow. And agents search differently from humans: humans are lazy, agents have a goal and are not, generating very specific queries and using quotes, site filters, and date filters — while every index in the world was optimized for human query traffic. Keenable innovates on index structures and builds a self-learning loop that continuously learns how agents seek information, exposing a web search API with search and fetch endpoints plus WebQL, a web query language whose premise is that you operate on the internet as if it were a database. His example: "what is the cheapest available H100?" — nuanced because of available, since the answer is usually "contact sales." In WebQL it scans the relevant pages, extracts prices, extracts feedback, and finds evidence that somebody actually obtained GPUs from that provider, with a date — an important signal that it will work. Free access to the search API, and a WebQL waitlist open through the end of August.

10. H Company (~03:53:31–03:58:50)

Louis, who leads US go-to-market, introduced a frontier AI lab with forward deployed engineers serving large enterprises, helping them turn messy fragmented operations into governed AI execution at scale — building and deploying agentic systems that remove bottlenecks, automate complex work, and complete tasks end to end. The differentiation traces to the research direction they chose when founded two years ago: VLMs — vision language models that can see screens and user interfaces, reason over them, and power agents that act directly on them. As a result their agents don't need APIs or connectors; they navigate computers the way humans do, through the front end, across desktop, web, legacy systems, and any screen. Earlier this year they announced breaking the computer-use frontier by topping the latest benchmark ahead of other frontier AI labs at one-tenth the cost, and they raised a $220 million seed round, the largest in Europe at the time, with partners including Accel and Amazon.

His core argument is that computer use is a foundational technology, categorically different from RPA: RPA executes scripts in static environments, while computer use understands context, adapts to UI changes, and acts dynamically. That matters because enterprise work is fragmented by design — HR, procurement, supply chain, all ERPs and CRMs that don't talk to each other. Rather than waiting for every workflow to be rebuilt around APIs, H works directly through the existing interface layer, changing the economics of automation. Finally, he argued that autonomy alone doesn't win the enterprise: you win with control and sovereignty — secure deployment, traceability, control over data, models, and execution, plus observability and keeping humans in the loop. "That is the difference between a demo and a production system." His close: the enterprise race is no longer about who has the smartest model, since everyone will have access to powerful models; what's scarce is controllable, autonomous, capable AI that works in the messy reality of enterprise systems. (A personal footnote: the last time he stood on that stage was eight years earlier for his own Berkeley graduation — "go Bears" — when campus was all about crypto and Bitcoin, certainly not AI.)

11. Ludo Robotics (~03:58:53–04:04:03)

A research team based in Palo Alto and Seoul, whose past work includes PUBG, PUBG Ally (the first AI agent that plays games alongside players using voice communication), Raon (state-of-the-art speech language models at their parameter size), and technology behind coding agents. Their framing: robots can be smart in two different ways — physically smart and socially smart — and right now we have neither at a high level. A physically smart but socially dumb robot is useful in factories, mostly in caged setups. But what about the other way around?

What if we take the current robots with the current level of physical capacity and give them really good social intelligence? They can walk around well, they can carry things around. If they can talk to people and understand people and society, they can probably start doing something very amazing. Imagine a humanoid who can walk your dogs, or pick up your kids, carrying their heavy backpacks and having some fun conversation walking back.

So Ludo deliberately takes the opposite path from most of the field: improve social intelligence on today's robots first. The product is Ludo 0.1, a research release — an agentic system for improving the social intelligence of current robots, controlled by a 4-billion-parameter local vision language model. The VLM handles perception and reasoning and decides which tool to call; the tools include VLA (the robot uses its body), navigation, and speech. Demo one: a man doing the dishes asks the robot to bring Chloe a Coca-Cola, then corrects himself — "I remembered her preference wrong, bring her Pepsi" — and the robot finds the person, navigates, picks and places the can on the table, and explains "Jake asked me to bring you this." Demo two: asked to check whether the water is boiling and whether the laundry is done, the robot goes to the kitchen and the washer, comes back, and reports "the laundry is finished but the water isn't boiling yet"; when the person says they'll fold the laundry while they wait, it answers, "Sorry, I can't help with the folding yet. If we close our next funding round, I might actually be pretty good at it." Next up is Ludo 1.0, a foundation model natively designed to do conversation and action in a single model, to be released later this year. Hiring in both offices.

12. Nimble (~04:04:09–04:10:00)

The closing presentation covered expert-level, self-learning web search agents for enterprise AI. The argument: models are very good at general information, so we infuse external context — and as we move from general intelligence toward specialized intelligence, wanting models to do more specific things, web search systems must specialize too. Their loop runs planning → searching → fine-tuning the model → results → a memory system for self-learning and optimization.

The contrast: a general retrieval system answers "what's the latest model winning a benchmark" fine. But specialized work wants a list of entities with all their parameters, in real time — which requires running many searches in parallel and pulling the most relevant information. So instead of one general retrieval system where the model emits a query and gets information back, they decompose it into specialized components: building the list, validating that information, semantic queries, and invoking specific tools — and the combination of those tools is what a specialized search system actually is. Applications span domains: better accuracy on general queries; a researcher who needs the model to be the best at proteins; someone in insurance or compliance who needs domain expertise. What they learned in practice is that scaling these systems requires training smaller retrieval algorithms: they build a knowledge representation of the domain expertise and embed it into 1B and 2B models specialized for that domain, which retrieve for the user's context, instead of using an extremely large model that would flood the context with chunks during deep research. The architecture combines a memory state and a self-learning algorithm that builds both the retrieval system and the domain-specific index, paired with real-time headless browsers that fetch what's needed from the web. The result is better accuracy and better performance and token efficiency across verticals. Available through a simple API.

Quotes

"Agents don't have a reasoning problem. They have a context problem." (~03:34, Headroom)

"The future of software is agentic. And because it's agentic, the future of access control is runtime." (~03:27, AgntID)

"Identity and authentication doesn't mean you're aligned." (~03:42, ArmorIQ)

"Every failure becomes a test, every change is measured, and every improvement is verified." (~03:32, RELAI)

"Sorry, I can't help with the folding yet. If we close our next funding round, I might actually be pretty good at it." (~04:03, the robot in Ludo Robotics' demo video)