Here’s a one-minute walkthrough: https://youtu.be/KJa3h6ZJNLQ
We also put together a post with example traces and analyses from flow-1 and other models: https://laminar.sh/blog/flow-1-in-action
Agent observability is crowded, so instead of a bullet list of how Laminar differs from X, we’ll explain how we’re solving agent observability from first principles.
Agents now run for many steps and fail implicitly. An agent can click the wrong button or cite the wrong document while every call completes successfully. These errors are the most useful ones to catch and understand. To find them, you need to understand what the agent was trying to do and inspect its LLM calls and tool results. Simply looking at the final agent output is not enough.
Collecting traces alone doesn’t solve this. A lot of agent observability platforms are still data collectors at their core. You can end up paying to store traces that nobody has time to read or extract value from.
Using another LLM to inspect traces is THE solution, but capable models are expensive at scale and cheaper ones often miss errors or flag unrelated things.
So we built our model to solve exactly this problem. We finetuned a small OSS model and then post trained it with RL on thousands of synthetic investigations of realistic agent workflows in software, legal, customer support, etc. We got a model that is both good at agent trace analysis and very cheap to run.
flow-1 runs inside a harness we call Signals. It acts as a coding agent, treating an agent trace like a repo, with each span (an LLM call, tool call, etc.) as a file. It starts from a compressed string representation of a full agent trace and a user prompt, then greps across spans and reads the relevant ones in full.
The beauty of Signals is that it can respond to a general prompt. You can ask it to identify user frustration, check whether your browser agent completed a checkout, and so on. It’s not limited to raw error detection. It returns findings as JSON in a schema users can freely define. We call these signal events.
Once you’re analyzing every trace, you also have too many individual events to read. That’s why we automatically group similar signal events into clusters. You can see recurring problems and how often they happen, then drill into individual events and the traces behind them.
You can use traces from a cluster to build an eval dataset for that type of failure. You can then use your favourite coding agent to hillclimb on those evals and check that the fix works across these cases before shipping it to prod.
Trace → analyze → catch errors and form clusters → fix → release. Making this loop easy is why we built Laminar.
We’ve put the same thought into the rest of Laminar. Our blog (https://laminar.sh/blog) explains how looking closely at how agents actually work led us to build 20x trace compression, a custom SQL query engine and automatic task extraction.
Laminar is Apache 2.0 and self-hostable (https://github.com/lmnr-ai/lmnr). We make money from the managed cloud.
We’d love to hear how you track your agents’ performance today. How much do you learn from user feedback versus your own monitoring? And when you fix something, how do you check that it hasn’t introduced a different failure?
Edit: I initially asked also about general tips for observing agents, but later, noticing that there were no interactions with my comment yet, edited my comment to remove that question, because I felt that it was too broad and would detract from my main question. To my surprise, both were answered by op after my edit; kudos!
Agent observability is based on similar primitives as regular observability (OTEL), but is wildly different. Trace payloads are huge, and errors are much more subtle, they are not increased latency or elevated 500 response rate. We recommend tracing everything in detail, and reading a few traces manually at the beginning while you iterate. At scale, the answer is almost always use another LLM look at your traces, which is what this post is all about.
Evals are critical. I really recommend adopting the Anthropic's capability / regression eval model [1]. We also deeply believe that agent evals should be end-to-end, and as high-level as possible. This again often involves a quality LLM-as-a-judge, tuned on a set of manually labelled data.
With this idea in mind (to answer your question), we think that, for eval datasets, the most crucial bit is to be able to store input of what your agent was asked about in production. Collect a certain distribution of inputs for happy and unhappy cases, and then run evals on those inputs. That's why Laminar went great lengths to help our users automatically get actual inputs their users send to their agents [2].
[1] https://www.anthropic.com/engineering/demystifying-evals-for...
[2] https://laminar.sh/blog/extracting-tasks-from-agent-runs
I wonder if you have thought of using this for the voice AI space for creating traces from many test calls to speed up testing of voice bots? It's true there are a lot of challenges _before_ one gets to the stage of running actual calls like creating good test data etc, but I wonder if you see a definite role for this framework in that space?
I assume you mean tracing voice agents in general. If so, it depends on the where do you want to trace things. Right now, Laminar, unfortunately, doesn't trace voice SDKs like OpenAI's realtime, but we're very actively looking into it.
However, if somewhere in your pipeline you have transcripts of your voice agents, then it shouldn't be that different from tracing any other agent. In this case, Laminar and Signals work perfectly.
We also trained and benchmarked flow-1 on a lot of multi-turn voice agent like conversations.
I'd say in general, with respect to errors/low quality responses etc you have to be extremely clear about what you are doing because once you get into the weeds, what is and is not an error is very grey in many cases.
Also, some of what you describe sounds expensive. Do you find these techniques + cheaper models better than single-shot with larger models?
Yes, it can get expensive. We do something in financial markets where the cost of a single end to end task could be $100. That doesn't mean cost doesn't matter though, it matters a lot - if we screw up and it propagates, it's money down the toilet. And if we could get the task down to $20, it would make a difference.
> Agent observability is crowded, so instead of a bullet list of how Laminar differs from X, we’ll explain how we’re solving agent observability from first principles
my brain shut down and bounced minus the comment because it's a launch and maybe you'd want feedback.
I'd be using this for post-training in a custom harness: so what you focused on during post-training and what it excels at are the most interesting things
I used GSPO because it worked really well for very long prompts (we're dealing with traces analyses so prompts are very very long, and by prompts I mean what goes into LLM call).
We RL-ed flow-1 in our harness, which made it very efficient at using tools it had. Our harness as I said in the post is basically coding agent, it has grep, read and couple of other aux tools. I spent a loooot of time and money on figuring out the right RL recipe and especially the reward. It was really hard to find the right balance between exploration and exploitation.
Some RL runs are still running, because the prod checkpoint as good as it is, thinks a lot. It produces a lot of thinking tokens, which affects the throughput, especially on the large, complex traces to be analyzed. So the next big challenge for me is to make it efficient thinker - i.e. reduce thinking tokens, without losing quality.
flow-1 actually predicts how critical each finding is