Lemma, Teri Shim

01Context

I shipped 67 pull requests as the founding designer at Lemma.

1,000,000: traces a day
10 → 30: customers
67: PRs shipped

I made the design decisions and a lot of the product ones: mockups and interfaces tried out with users, workflows worked through end to end. Then I built them directly in code, shipping PRs and taking engineering tickets alongside the prototypes.

Over one summer I led a rebrand, rebuilt the design system, and redesigned every core surface. This is one of those surfaces.

Fig. 1The Traces detail, left panel semantic and right panel literal.

02Problem

Lemma is the production monitoring platform for agents.

Agents in production fail in unpredictable ways.

Stuck in loops, faulty tool calls, degrading context. Nothing throws an error, but users notice… then they churn.

To find a single silent failure, an engineer has to sift through 234567890125678901234512345678901789012345673456789012345678901234 traces.

With Lemma, you don’t. Catch issues with Issue Extraction.

Lemma looks through your traces and extracts these silent semantic failures, so your engineers don’t have to.

Fig. 2An extracted issue: what it is, how much of the traffic it touched, and every run behind it.

Lemma's ICP is conversational agents. Like the customer service agent you might talk to while shopping on Amazon.

Because the agents are conversational, the issues live in the conversation, so when we search for issues, we search inside conversations.

can you cancel my order? i don’t need it anymore

Done. I’ve cancelled order #4471, you won’t be charged.

The cancel never executed. No error was thrown.

wait it still says shipping. did it work? it didn’t go through, why didn’t it go through?

Your cancellation was processed successfully, nothing further needed.

Doubles down rather than re-checking.

Occurrences3Sessions3

The agent replied “Done. I’ve cancelled order #4471” with no cancellation call anywhere in the trace. When the user reported the order was still shipping, it reasserted the cancellation rather than re-checking.

Trace a3f19c04Session s_88c1open issue →

The refund tool returned a pending status the agent read as success. It told the user the money was on its way back, and repeated it when they said their statement was unchanged.

Trace 7d20be51Session s_91a4open issue →

The agent summarised the new shipping address back to the user and confirmed the update. No write reached the order service, and the trace ends with the original address intact.

Trace c418a7d0Session s_9f30open issue →

Fig. 3Example issue, rendered in the product’s conversation view.

Every alert is a claim Lemma is making. The developer's first job is to confirm or reject it.

The loop runs Slack to issue to trace:

Fig. 4The core loop. Hover a step to see the surface it happens on.

An alert fires, the developer opens the issue, and drills into a trace to verify it.

Unlike traditional observability platforms, traces is not a log viewer. It is the verification step of the core loop.

A traditional observability platform shows the JSON and logs, because latency and tool-call errors and the other data attached to a trace is what matters there.

Braintrust's Logs view: a table of traces, a span tree, and a right rail of metrics — start, duration, token counts, estimated cost — with the actual input and output collapsed into a small box near the bottom — Fig. 5Braintrust. The metrics lead; what was actually said is a small box under them.

And that makes sense for what traditional observability serves.

That layout fits background and voice agents, which have no conversation to read and live on metrics like cost.

Agent type	What matters most
Background agent	Did it execute, and what did it cost
Voice agent	Latency
Conversational agent	The conversation itselfLemma

A traditional platform has to serve all three, so it builds for what they have in common: cost and latency. That is where most teams start too. The semantic failures — the agent that drifts, loops, or quietly says the wrong thing — only surface once it is in production, and a conversation UI is no use to the two agent types that have no conversation to read.

Except Lemma is for conversational agents, where verifying an issue means reading what was said.

So we needed to make the conversation readable.

The solution: a conversation UI in every trace detail.

Lemma's trace detail before the redesign: a navigation panel of turns and spans on the left, an inspector of raw JSON on the right — Before

The trace drawer after the redesign: the exchange read as a conversation, with the tool calls under the turn — After

03Solution

Read traces exactly like how a user would.

Group together traces as threads to see entire conversations.

Click around through this embed of the platform UI, and use keybinds to trawl through exchanges and spans quickly.

th_happy_thread3 traces · support-agent

↑↓spans

Thread conversation view

3 traces·4.2s

Where is my order?

Order #8812 shipped on Sep 1 and is out for delivery today. The carrier scanned it in Oakland at 6:42am.

That's not the one I meant — the standing desk

That is order #8790, the Ashcroft standing desk. It is still with the warehouse: freight items ship separately, and this one is booked for pickup on Sep 8.

Can I get it before the 8th?

Not on freight, but I can move it to expedited for $40 and it would arrive Sep 5. Want me to do that?

Exchange 1 of 3

Span tree

1.40s4 spans

support-agent

4.20s

ai.generateText

1.00s

getOrderStatus

320ms

ai.generateText

2.60s

Span detail

Select a span to view details

The conversation view, running. Press a state, and the panel re-resolves the way it does in production.

04Tradeoffs and states

Except the readable version only works when an agent is perfectly instrumented to produce it.

If an agent wasn’t instrumented properly per Lemma’s standards, outputs or inputs were often dropped. Leading to strange empty states with no direction.

G5 — a captured question, “What is my order status?”, and where the agent's reply should be a dashed box reading No output; the span tree beside it shows the run completed in 4.20 seconds across four spans — Fig. 6aAn agent that is instrumented properly might still throw no output or no input, and the convo UI had no direction for what to do with that.

The UI needed to be adaptable.

A whiteboard headed adaptive UI, with convo, msg agents and background sketched as three shapes, and at the foot: A has input, B has output, C input is text, D has user_msg tools, with the branch under them — if not C and not B, background agent; if D, msg agent; else convo agent — Fig. 7Working out the states, and the variables that decide which one a trace gets.

Properly instrumented conversational agents
User and agent turns as a real exchange, with the flagged occurrence inlined at the turn it belongs to.
Background agents, or agents with no readable input and output
Structured runs render as input and tool calls with progressive disclosure.
Message agents, where some turns land and some do not
Within one conversation, captured turns render as bubbles and the uncaptured ones hold their place, so the gaps are visible against the exchanges around them.
Agents sending no input or output at all
When no input or output arrives, it means the agent was definitely not instrumented properly, per Lemma standards.

If the input and output are empty, wouldn’t it be better to let the span detail take the space instead of showing this empty state?

My CEO asked this, and it was a fair question. A setup block that size is a lot of screen to give a trace that has nothing to show, and the span detail is the one panel that still has something in it.

I decided to make the tradeoff because Lemma cannot function at full capacity if customers are not able to validate issues.

Without input and output captured, nobody can validate an issue at all, and a span detail filling the space would have let them go on not knowing that. The empty state is the only screen in the product whose job is to say what is wrong and how to fix it.

It paid off. Customers instrumented their agents, started validating issues, and stayed.

05Workflow

As Lemma’s first design hire, they had no Figma file (lol). So I designed in code.

And at first, I fell into the trap of refining instead of iterating.

A Linear ticket, DES-98, titled “Polish: release chip — add the missing hover state to the copy variant”: a summary naming the component and why it receives no hover, and a Target table giving the route, the file, the element, the line reference and the Storybook stories — Fig. 8aExample ticket written with the skill I made, which finds all the correct paths and writes acceptance criteria so an agent can’t mess it up. All I have to do is say a sentence or two about what I want.

Here’s how I ended up changing my workflow to fulfill my job as a designer.

On paperWhere the iterating happened.

Fig. 9aThe notebook it was worked out in, paged through: artifact layouts, key actions, empty states, and a page of doodles that got in the way.

Prototyping with live dataDesigning the platform’s agent chat meant designing what the agent says back. What it says back is generated, so in Figma there is nothing to draw.

Fig. 10aAsking Inspect for slow traces in the last hour: it writes the filter, ranks the eight it finds, and says what they have in common.

Wherever there wasn’t a tool. Poof! Now there is one.

plumbkitA downloadable alignment tool, to check object alignment and make it easy to tell an agent what to fix.

Fig. 11aplumbkit counting what is aligned, what is near and what is lone, naming the offset it found, and copying it out.

06Result

The surface shipped to production and now adapts across the full range of instrumentation, from clean conversation to no data at all.

It went out incrementally across roughly eight pull requests while customers were using it, structured so the cheap version and the correct version are the same code with the classification window as a parameter.

1,000,000: traces a day
10 → 30: customers
67: PRs shipped

Our CEO received many reviews from our customers saying how much they liked it, and how much easier it made it to read through traces.

Especially for the main user of the platform UI, non-technical product managers.

Definitely a good boost for me hehe.

we’ve been using @lemma_ for observability and it’s legitimately awesome
the thing we love is that it understands what your agents are supposed to do, instead of making you define every possible failure mode upfront
also this team is absolutely goated
congrats @zjearbear

conor brennan-burkeHyperspell

Agents can look like they’re working even when they’ve failed. Lemma catches that before users do. Jerry and Cole are deeply technical and move absurdly fast.
Huge congrats on the round @zjearbear, @colegawin_, and the whole @lemma_ team!

Nicolas DessaigneY Combinator

Very excited to be working alongside the Lemma team!

Baptiste DLucis

congrats to the lemma team! we switched over from raindrop a while back at folk and the difference is that lemma actually understands what your agent is supposed to do, so it surfaces issues on its own instead of us setting up signals and tracing everything ourselves. huge for consumer agents where the surface area is massive.

Chenxin Yanfolk

@lemma_ team making movies and banger software.
We got set up on lemma in <10 min using their agent skill. almost immediately it flagged an issue that had gone unnoticed in prod for 20+ days, really cool product

Hai Ta (YC P26)Userlens

Every morning, I check our frontend logs -> backend logs -> Lemma logs, then pipe any issues straight into Claude (copy paste, i dont read any of the errors atp).
Love the Lemma team. Gave me the easiest way to find where our agent did something that wasn't exactly what our user wanted.

Adhit SankaranJanet AI

can confirm: agents f*ck up. @TextZeme's volume is growing faster than any human could review, so @lemma_ is how we find out before our users tell us. Congrats on the raise @zjearbear

Elior AlayevZeme

Agents are getting better. Their mistakes are getting weirder.
This is why we invested in @lemma_ . Sign up before your agents turn everything into paperclips.

Jenny HeFounder & General Partner, Position

Well deserved, been working with the lemma team since we were still in the yc batch together. they ship fixes the same day we mention something in slack. crazy cracked team

Kevin LeCladlabs (YC F25)

I've known this team since they first started, they are incredibly relentless, and the talent is unmatched.
Behind every great company is always a great entrepreneur I would bet on @zjearbear & @colegawin_ any day - their grit & hustle is next-level.

Danylo BorodchukLopus (YC W25)

i would bet money on the @lemma_ team

Prama YudhistiraParameter

What customers posted after the launch.

07Currently

This is only one surface of the Lemma redesign.

Other projects include designing the actual issues page, building a Lemma skill for interfacing through any chosen coding agent, and more.

Shipping 67 PRsat Lemma

I shipped 67 pull requests as the founding designer at Lemma.

I made the design decisions and a lot of the product ones: mockups and interfaces tried out with users, workflows worked through end to end. Then I built them directly in code, shipping PRs and taking engineering tickets alongside the prototypes.

Lemma is the production monitoring platform for agents.

Agents in production fail in unpredictable ways.

Stuck in loops, faulty tool calls, degrading context. Nothing throws an error, but users notice… then they churn.

To find a single silent failure, an engineer has to sift through 234567890125678901234512345678901789012345673456789012345678901234 traces.

With Lemma, you don’t. Catch issues with Issue Extraction.

Lemma looks through your traces and extracts these silent semantic failures, so your engineers don’t have to.

Lemma's ICP is conversational agents. Like the customer service agent you might talk to while shopping on Amazon.

Because the agents are conversational, the issues live in the conversation, so when we search for issues, we search inside conversations.

Every alert is a claim Lemma is making. The developer's first job is to confirm or reject it.

The loop runs Slack to issue to trace:

An alert fires, the developer opens the issue, and drills into a trace to verify it.

Unlike traditional observability platforms, traces is not a log viewer. It is the verification step of the core loop.

And that makes sense for what traditional observability serves.

That layout fits background and voice agents, which have no conversation to read and live on metrics like cost.

Except Lemma is for conversational agents, where verifying an issue means reading what was said.

So we needed to make the conversation readable.

The solution: a conversation UI in every trace detail.

Read traces exactly like how a user would.

Click around through this embed of the platform UI, and use keybinds to trawl through exchanges and spans quickly.

Except the readable version only works when an agent is perfectly instrumented to produce it.

If an agent wasn’t instrumented properly per Lemma’s standards, outputs or inputs were often dropped. Leading to strange empty states with no direction.

The UI needed to be adaptable.

Properly instrumented conversational agents

Background agents, or agents with no readable input and output

Message agents, where some turns land and some do not

Agents sending no input or output at all

As Lemma’s first design hire, they had no Figma file (lol). So I designed in code.

And at first, I fell into the trap of refining instead of iterating.

Here’s how I ended up changing my workflow to fulfill my job as a designer.

Wherever there wasn’t a tool. Poof! Now there is one.

The surface shipped to production and now adapts across the full range of instrumentation, from clean conversation to no data at all.

Our CEO received many reviews from our customers saying how much they liked it, and how much easier it made it to read through traces.

This is only one surface of the Lemma redesign.

Everything I shipped over 3 months as Lemma’s only designer

I shipped 67 pull requests as the founding designer at Lemma.

I made the design decisions and a lot of the product ones: mockups and interfaces tried out with users, workflows worked through end to end. Then I built them directly in code, shipping PRs and taking engineering tickets alongside the prototypes.

Lemma is the production monitoring platform for agents.

Agents in production fail in unpredictable ways.

Stuck in loops, faulty tool calls, degrading context. Nothing throws an error, but users notice… then they churn.

To find a single silent failure, an engineer has to sift through 234567890125678901234512345678901,789012345673456789012345678901234 traces.

With Lemma, you don’t. Catch issues with Issue Extraction.

Lemma looks through your traces and extracts these silent semantic failures, so your engineers don’t have to.

Lemma's ICP is conversational agents. Like the customer service agent you might talk to while shopping on Amazon.

Because the agents are conversational, the issues live in the conversation, so when we search for issues, we search inside conversations.

Cancellation confirmed, never executeda3f19c04

Refund confirmed against a charge that never settled7d20be51

Address change acknowledged, never writtenc418a7d0

Every alert is a claim Lemma is making. The developer's first job is to confirm or reject it.

The loop runs Slack to issue to trace:

An alert fires, the developer opens the issue, and drills into a trace to verify it.

Unlike traditional observability platforms, traces is not a log viewer. It is the verification step of the core loop.

And that makes sense for what traditional observability serves.

That layout fits background and voice agents, which have no conversation to read and live on metrics like cost.

Except Lemma is for conversational agents, where verifying an issue means reading what was said.

So we needed to make the conversation readable.

The solution: a conversation UI in every trace detail.

Read traces exactly like how a user would.

Click around through this embed of the platform UI, and use keybinds to trawl through exchanges and spans quickly.

Except the readable version only works when an agent is perfectly instrumented to produce it.

If an agent wasn’t instrumented properly per Lemma’s standards, outputs or inputs were often dropped. Leading to strange empty states with no direction.

The UI needed to be adaptable.

Properly instrumented conversational agents

Background agents, or agents with no readable input and output

Message agents, where some turns land and some do not

Agents sending no input or output at all

As Lemma’s first design hire, they had no Figma file (lol). So I designed in code.

And at first, I fell into the trap of refining instead of iterating.

Here’s how I ended up changing my workflow to fulfill my job as a designer.

Wherever there wasn’t a tool. Poof! Now there is one.

The surface shipped to production and now adapts across the full range of instrumentation, from clean conversation to no data at all.

Our CEO received many reviews from our customers saying how much they liked it, and how much easier it made it to read through traces.

This is only one surface of the Lemma redesign.

Everything I shipped over 3 months as Lemma’s only designer

To find a single silent failure, an engineer has to sift through 234567890125678901234512345678901789012345673456789012345678901234 traces.