Lumen

The short version

Lumen is a code name. The product is confidential, so names and identifying details are withheld.

• Problem: Complex machines emit far more state, telemetry and logs than people can read. Understanding, not deciding or acting, was the slow and expensive part of the job.
• Bet: Use AI to make machine state instantly understandable, in plain language, with the raw truth always one step away.
• Result: One experience built around a single promise: you should never have to decode your own machines. Ask, and the system explains. Then act without leaving the thread.

The problem worth solving

Operators weren’t short on capability or data. They had so much of both it became overload. Their daily job is situational awareness across many machines and flows: what’s running, what’s healthy, what’s drifting, what just happened and why.

Two facts defined the opportunity:

• Understanding was the bottleneck. Reconstructing what a machine was doing meant scanning long logs and dense telemetry. By the time you’d parsed it, the moment could be gone. Raw data doesn’t scale to human attention.
• Clarity compounds. On machines this important, grasping a complex state in seconds instead of minutes means fewer surprises, faster reactions and more confident decisions.

How do you turn an overwhelming, ever-changing stream of machine state into something a person can grasp at a glance, question in plain language, trust completely and act on?

My role

Product design across research, information architecture, interaction and systems design, plus shaping the product strategy together with product management and engineering.

The strategy

The defining decision was where to point the AI. The loud move is to make agents do things. The higher-leverage move was to make AI the thing that gives operators understanding, and let action follow from it in the same flow.

The principles behind every decision:

• Ask, don’t read: plain-language answers replace log archaeology.
• Depth is opt-in: a one-line status by default, the raw trace on demand.
• Honest by default: the product says plainly what it can’t show.

Key decisions

1. The agent as a comprehension layer, everywhere

Operators ask what happened, when, why, and whether it’s normal, and get answers in plain language. The agent is reachable from every surface and always carries the context of what you’re inspecting. It isn’t a feature in one tab; it’s the lens the whole product is seen through.

Why: the product’s value is shrinking time-to-understanding, and giving that understanding to more people, not only the few who read logs fluently.

2. Total situational awareness at a glance

Clear status across machines, surfaced signals instead of buried ones, the shape of each flow, and concrete progress with expected completion, so people can plan around a machine instead of babysitting it.

Why: “Is it alive, and is it okay?” has to be answerable in one look before anything else matters.

3. A direct, real-time view you can rely on

A live view of the operation is a persistent, first-class element. When it can’t be shown, the product says so plainly rather than faking a frame.

Why: a system that’s candid about what it can’t show is one people believe about what it can.

4. Every answer verifiable in one step

The agent gives a clean summary, and the raw logs and telemetry are always one step behind it. The summary is a fast lane laid over the source, never a wall in front of it.

Why: AI earns trust when the truth is always one step away. It also gives a clean audit trail, which is exactly why operators are willing to move fast on it.

5. From understanding straight to action

Understanding and action live in the same thread. The moment an operator grasps what’s going on, the response is right there, with no tool-switching, no rebuilding context.

Why: closing the loop (see, understand, act, see the result) turns an observability tool into the place where work gets done.

The hard trade-off

Clarity vs. completeness. A summary clean enough to grasp instantly can leave something out, and on complex machines the omitted detail occasionally matters. Too much completeness recreates the wall of logs; too much simplicity implies more certainty than exists.

The resolution was a principle rather than a setting: every summary makes it cheap and obvious to go one level deeper. Clarity is an invitation into the detail, never a substitute for it.

Impact

The product’s value is understanding, so success is measured in clarity and confidence:

• Time-to-comprehension: from “something’s happening” to “I understand it”. The headline metric.
• Reach of understanding: how many people can confidently read a machine’s state, not only log experts.
• Anomaly-catch latency: how quickly a developing situation is noticed and understood.
• Verification habit: a steady rate of drop-to-source checks: trust, not blind faith.
• Confident action: understanding turning into the right response, in flow.

What I learned

The headline story for AI on complex systems is autonomy. The more valuable story is comprehension: turning overwhelming complexity into instant, trustworthy clarity. The work wasn’t making a machine smarter. It was making a person more capable.