@LangChain: Austin Berke, Lead AI Product Engineer at @Harmonic recently shared how they rebuilt Scout on Deep Agents, quadrupling …

Austin Berke, Lead AI Product Engineer at @Harmonic recently shared how they rebuilt Scout on Deep Agents, quadrupling retention along the way.

Watch the full fireside chat at https://t.co/WTE470p7VQ https://t.co/1MKtizqOTO

TL;DR: Harmonic rebuilt Scout on Deep Agents, quadrupling week-1-to-week-4 retention. The key was connecting context across the agent, frontend, and deterministic processes—using the file system as shared storage instead of letting the model “fire and forget.”

What Are Harmonic and Scout

Harmonic is a real-time database for the startup ecosystem, tracking 37 million companies, 200 million people, and 220,000 investors, and growing every week. The vast majority of top VCs rely on Harmonic for sourcing—9 of the top 10 VCs currently use Harmonic.

Scout is a natural-language interface built on top of the entire ecosystem, running on Deep Agents and connected to the data. It can handle simple queries like “Who is the CEO of LangChain?” as well as very complex tasks like “map out the landscape of this industry,” “create a market-map visualization,” or “score these teams from 1 to 10 based on this rubric.” Under the hood, it’s basically a tool loop: execute a task, then render the response to the user. The interface combines a chat experience similar to Claude Code or ChatGPT with some custom interactive elements—click a company, add to a list, pull out a sidebar—so you can interact while still keeping an agentic conversation flow.

Results After Moving to Deep Agents

These are impressive metrics: since switching to Deep Agents, Scout’s week-1-to-week-4 retention improved 4x.

Qualitative feedback has been strong too. One person said: “I’ve talked to some colleagues at other companies, and I think everyone’s secret weapon is becoming Scout.” Another said: “It’s like heaven for me.”

From Scout 1.0 to Deep Agents

Scout 1.0 was the initial version—roughly state of the art a year and a half ago, but it quickly became outdated. The idea was: how do you handle a natural-language query like “Show me all fintech SaaS companies that raised in New York in the past two months”?

Back then there was a query-parsing graph. Given a query, it would:

• Extract the semantic part (fintech SaaS) and run it against embedding vectors
• Get the location information
• Get the funding part and route it to a custom search language

In LangGraph, every node had its own model and its own evals, requiring a lot of maintenance and constant tuning to pass the evals.

Fast forward to now: models are better and frameworks have appeared, so they switched to Deep Agents. The new architecture’s graph is much simpler: in the middle is just a single tool-calling loop, made up of model, tools, and middleware. Middleware runs before the model, after the model, and before and after the agent. The whole thing is a tool-calling loop.

Scout is now basically model plus tools. They built a set of tools that connect to the ecosystem, from searching entities and using Tavily to search the web, to enriching by ID, enriching by URL, and interacting with the user’s CRM—adding to lists, operating on lists, moving things around.

What they found: with frontier models and frameworks, if you give the model a bunch of tools (even 50 tools), it’s very good at choosing the right tool and executing very complex, long-horizon combined tasks.

Why Deep Agents

With 50 tools and lots of interactions, some threads get very long. For example, a company search can return 1,000 results, and each result may contain nested team members, funding information, and so on. Once the actual response comes back, it can be thousands or tens of thousands of lines long, depending on what the model chooses to pull in. If you just pass that through the message list, it gets very crowded very quickly.

One of Deep Agents’ core benefits is how it manages context:

• Compression: as the message list grows, it runs compression, letting the agent continue indefinitely.
• Tool-call eviction: for something like that company search returning thousands of lines, Deep Agents pulls it out into the file system and returns a pointer describing how to pull the file contents in chunks. The model can keep running without being polluted by the entire response.
• Skills and custom middleware: you can pull prompt information into the runtime instead of including everything in every call.
• File-system abstraction: you can freely read and write different artifacts into the agent.
• LangSmith integration: wiring the new framework into an existing graph is very simple. Users still see the same chat interface, and the team can incrementally A/B test and migrate users over.

Agent vs. Product: Model + Framework + UX

If an agent is model + framework, then the product is the agent plus some user experience that lets people interact with it well. In Scout’s case: frontier model + Deep Agents framework + a custom web interface.

There’s a core tension: agents like things that are “code-like”—models are trained on coding tasks, tool calls, and structured JSON, and they like structuring responses as XML or JSON. The framework also has file-system primitives; it writes markdown and outputs things like “Hey, I wrote this file to this path.” But users don’t want to see that, especially since most Scout users are non-technical.

So you have to navigate that tension: how do you take full advantage of the framework—which is extremely powerful when paired with frontier models—and still build it into a product that’s useful to ordinary people, without sacrificing capability.

The Framework Context Contract: What’s Invisible to the Model

Deep Agents manages context in a way that essentially holds a contract with the model:

• The model always receives just a message list: assistant messages, human messages, tool messages.
• Every time you call the model, you pass in a message list, and the model streams back what should come next.
• The framework’s job is to take things out of the message list to free up space, making sure you