I've been demoing this wrong: Why one agent isn't the answer

I've spent more than half my career in a lab, running experiments and wrangling bioinformatics tools to answer questions about transcriptional regulation in developmental biology. Then I moved into software, because I kept hitting the same wall: the people who needed multimodal data couldn't get at it without a specialist in the room. I've led scientific solutions work at places like Qiagen and DNAnexus, and now do the same at Manifold. Across all of it, one aspect of my work has stayed constant: walk into a room, open my laptop, and show you something cool.

There's a name for that role inside companies where I’ve worked.

Demo monkey.

I'm only half joking, but this is how it unfolds. The salesperson teases the meeting, the demo monkey shows the magic, the customer leans in, and the contract gets signed. Rinse and repeat.

I'm here to tell you I've been doing it wrong. And if you've been buying software this way, so have you.

The demo ritual

On the buyer side, you're evaluating a platform. You sit through a 30-minute demo. The vendor shows you one workflow, beautifully scripted, on data they've prepped for six months. You see the aha moment. You're impressed.

Then one of two things happens. Either you're under pressure to buy, so you sign, and six months later you find out the demo was the whole product. Or you're skeptical, you ask to see something else, and the demo monkey says, "oh, that's on the roadmap."

This ritual exists for a reason. For the last decade, building software was hard. A vendor could realistically only show you the one thing they'd actually built well, so we all got good at curating that one workflow, hiding the seams, and selling one slice as if it were the whole pie. I say that as someone who's been on the giving end.

That world is gone, and the reason it's gone is the thing everyone reading this is already using.

A single agent isn't a product

There’s a growing number of people who have prototyped something in Claude or ChatGPT. Your data scientists are doing it. Your translational teams are doing it. Your med affairs folks are doing it.

A single-agent wrapper around a frontier model isn't impressive anymore. It's table stakes. In 2020, building a demo took six months and a team. In 2026 it takes a weekend and Claude. So if a vendor walks into your office and the entire pitch is one cool agent, what they're showing you is something your own team could build in a hackathon.

The question isn't whether a vendor can show you a clever agent. These days, everyone can. The question we should be asking every vendor is: what happens after the demo?

When you run that same workflow on your real data, with your governance requirements, connected to the rest of your stack, with a second agent that does the next step and a third that does the subsequent step, does the magic survive?

The reality is that for most of what you're being pitched right now, it doesn't. The magic is the demo, and the demo is the product.

What real work actually looks like

As a Solutions Lead at Manifold, I often meet with folks evaluating platforms for multimodal data, and for a long time, a demo has basically been a cohort browser tool with some AI chat functionality. But as we transition into this era of rapid prototyping, I’ve seen a growing need to incorporate the demo into a real organizational workflow.

Here’s what a real workflow looks like.

Pick a translational question. You pull a cohort from a few data sources, some internal, some external, each with its own consent framework. You define that cohort precisely enough that someone could reproduce it six months from now in a regulatory filing. You run the analysis. You drop into Python or R for a custom step the off-the-shelf tool doesn't handle. You write the results back somewhere they can be governed, audited, and reused.

That's not one agent. That's four or five, handing off to each other, on data that's actually yours, with lineage that holds up.

This is the part the frontier models alone can't do, and not because it isn't smart enough. It absolutely is. It's because the model isn't connected to your data, your governance, your pipelines, your infrastructure. The model is the easy part. The plumbing is the hard part, and the plumbing decides whether the workflow survives contact with your real work.

That's what we've built at Manifold: a governed data layer with specialist agents sitting on top of it. One agent ingests and harmonizes data across sources. One defines and stores reproducible cohorts. One runs the analysis. One drops in code when a pre-built workflow doesn't fit. The whole thing writes back to a governed environment with lineage, so what you did is auditable and reusable.

No single piece of that is impossible to build. You could build any one of those agents in a weekend. What takes a real platform is making them work together, on real life sciences data, with the governance and connectivity that lets the work outlast the demo.

A different way to evaluate

So here's the version of this conversation I'd rather have. Instead of me curating one path and showing it to you, bring your actual question and walk the path yourself. Not a sandbox of dummy data, but your real data, your workflow, your team.

The actual product, not just a demo.  Bring a real problem, and we'll run multi-agent on your data, in front of you.