How We Built Olli: One Agent That Actually Understands Your Deals

Foundation Capital recently dropped this post showing why context graphs (systems that capture what they call “decision traces,” not just data) represent the next trillion-dollar opportunity. The idea is this: AI models are becoming commodities, so the advantage is building up specific knowledge about how a company actually sells (in our use case), to drive higher quality decisions and actions.

In short, I agree. 

I've spent my last decade watching the same problem play out across hundreds of sales orgs: the context that actually determines deal outcomes is scattered, lost, or trapped in people's heads. Salesforce captures the outcome. It doesn't capture what drove them.

At first, I built frameworks to shape my sales reps’ thinking. But when I co-found Fluint and we built Olli, our AI sales assistant, along with our CTO and my co-founder, Jon, we took a different technical path than what most sales tech companies are doing.

The Standard Playbook (And Why We Didn't Follow It)

The obvious approach (e.g. AgentForce, Gong, and every AI agent) looks like this: 

1. Deploy specialized agents for each workflow. A research agent. An outbound agent. A meeting prep agent. A follow-up agent.
   
   
2. String them together with integrations and call it a platform.

The problem is that workflow agents are “stateless.” They run, produce an output, and disappear. They never build a continuous understanding of the deal. They can't compare what's working across deals because they don't persist long enough to see those patterns.

The other common approach is a “per-deal agent.” One agent assigned to each deal, maintaining state over the full lifecycle. Which is better, but it creates a different problem: thousands of isolated agents, each learning locally, none of them sharing what works.

We went in a third direction.

One AI Agent, with Full Deal Context, Across Your Entire Pipeline

Olli is a single agent with a variety of skills. One agent that ingests all the context across your GTM org (calls, emails, Slack, CRM, documents, etc…) and maintains an understanding of every deal, at once.

Which was a requirement driven by what we were trying to solve.

Here's the reason: 

The most valuable thing an AI can do for a rep isn't summarize a call or draft a follow-up. 

It's to answer the question: What actually works in situations like this?

That question requires comparison. You need to look across deals, find similar patterns—similar objections, similar stakeholder dynamics, similar stall points—and surface what top performers did differently. 

You can't do that comparison if your agents are siloed by deals or by workflow.

The Technical Architecture Behind Olli:

1. Dynamic Models

Although we package up “Olli” as a single “person” you can talk with, he’s actually a composite of multiple models. Different tasks have different requirements. Synthesizing a complex multi-threaded deal history needs depth. Drafting a quick internal update needs speed. Crafting a visual for a live presentation needs design. Comparing patterns across hundreds of deals needs scale.

So Olli picks the right model or skill for each task. Heavy reasoning for strategy recommendations. Lightweight models for routine synthesis. Specialized fine-tunes for domain-specific work like business case generation.

This isn't just cost optimization (though it is that too). It's about matching models and skills to the job-to-be-done.

2. Unified Data Layer

Most GTM stacks treat each tool as a separate source of truth. Your call recordings live in Gong. Your email threads live in Gmail. Your deal stages live in Salesforce. Your internal discussions live in Slack.

Olli treats all of it as one continuous stream of deal context. Not by building another dashboard that aggregates views, but by actually reasoning across the full context when making recommendations.

When a rep asks "what should I do next on this deal," Olli isn't just looking at CRM fields. 

It's connecting the procurement objection from last week's call, the internal Slack thread about pricing flexibility, the competitor mention in an email, with the pattern from three similar deals that closed last quarter.

3. Cross-Deal Pattern Recognition

This is where the single-agent approach pays off.

Olli continuously builds out a map of what works. Not "best practices" from a playbook written two years ago. Actual patterns from your deals, with your buyers, in your market.

When a deal stalls at security review, Olli can surface: 

"In 4 similar deals that got stuck at security, the ones that closed had direct CISO engagement by day 3. The ones that didn't typically died." That's not a guess. That's pattern extraction from your own data.

And, here’s the thing: while Olli’s learning compounds over time, and every deal that closes (or doesn't) adds signal, he comes pre-trained. Learning from past deals across others, so you’re not starting from scratch. 

Then, every decision a rep makes—what they accepted, edited, or rejected from Olli's recommendations—becomes training data for what works in your specific context.

Why This Matters for Stuck, Mid-Funnel Deals

Most deals don't die from competitive loss. They die from inaction. Stuck in legal. Stalled waiting for a stakeholder. Delayed because the champion couldn't sell it internally.

The traditional fix is more process. Better stage definitions. More required fields. Weekly pipeline reviews where managers ask reps to justify their commit.

None of that addresses the actual problem: reps don't know what to do next because the playbook doesn't cover their specific situation.

Olli solves this differently. Instead of more process, he surfaces patterns: "Deals with this profile that stalled at this stage recovered when reps did X. Here's how to apply that to your deal."

Then, he actually goes and does it with you.

What We Learned Building This

A few things surprised us:

1. Integration depth matters more than breadth. We initially thought covering more tools would be the priority. Turns out, going deeper into fewer sources—actually understanding the context in a call transcript, not just indexing it—delivers more value than shallow coverage across 15 integrations.
   
   
2. Reps want rationale, not just recommendations. "Do this next" isn't good enough. Reps need to understand why, especially when the recommendation contradicts their instinct. The pattern evidence—showing similar deals and what happened—makes the guidance actionable instead of ignorable.
   
   
3. The “decision trace” is the product. The original post talks about capturing decision traces. We found that the trace isn't just for training. It's useful for the rep in the moment. Showing them: "Here's what you tried, here's what happened, here's what similar reps tried in similar situations" makes the next recommendation credible. And guides the human in the loop.
   
   
4. Local learning needs to become global learning. The biggest unlock isn't helping individual reps on individual deals. It's encoding what works so the whole org gets better. A new rep shouldn't have to rebuild bespoke knowledge through trial and error. The patterns should be accessible from day one.

The Shift from System of Record to Context to Action

Salesforce won because it gave leadership a place to see pipeline. But it never gave reps a reason to keep it accurate, because it didn't do anything for them.

The next platform wins by flipping that. Reps engage because the system actually helps them close. Leadership gets accurate forecasts as a byproduct, because the context is captured during execution, not retroactively entered into fields.

That's the bet we're making with Olli. 

A system that captures context during execution, with Olli delivering the work embedded alongside human sellers, learning from patterns and compounding what works.

‍

If you're dealing with stuck deals and want to see how pattern-based guidance works in practice, check out what we're building: fluint.io/request-demo