Going Beyond Observability to Understandability with Causely
The observability market is crowded — but maybe that’s the point. With distributed systems becoming the norm, engineering teams aren’t suffering from a lack of data. They’re drowning in it. Amid dashboards, alerts, and countless traces, Causely offers something radically different: a focus on the “why” instead of the “what.”
Today we sit down with Yotam Yemini, CEO of Causely, to explore what sets the company apart, why root cause matters more than ever, and how they’re making causal reasoning accessible — not magical. Yotam highlights Causely’s latest product updates, including a Grafana plugin listed in the Grafana marketplace, which allows engineers to view inferred root causes directly in their dashboards, avoiding context switching.
Watch&Listen to the full interview here.
Yotam Yemini
CEO of Causely
Why do we need Causely when observability giants already dominate the space?
Most observability platforms are designed to help engineering teams look at more data, not to automatically understand it. They flood you with alerts, charts, and dashboards. But visibility doesn’t equal control. Causely takes a different stance: we start by inferring the root cause of an issue and then expose supporting evidence. It’s a top-down approach versus the traditional bottom-up search for answers.
To make it work, we’ve built a causal reasoning engine powered by a generic knowledge base of failure modes — things like dependency saturation, service bottlenecks, or network latency. When we integrate into a customer’s environment, we map their real-time topology using OpenTelemetry or existing APMs. Then we use probabilistic models — specifically Bayesian networks — to generate a causality graph that adapts dynamically as their architecture evolves. It’s math, not magic. And we’re transparent about that.
Cloud-native systems are messy. Doesn’t that make root cause even harder to find?
That’s where we shine. If you’re running a simple monolith in one VM, you probably don’t need us. But modern systems, with microservices triggering cascading failures, make it nearly impossible to trace causality manually. That’s our perfect use case. We thrive in environments where one slow service can domino across dozens of others.
What’s new with your Grafana integration?
We’ve launched a signed data source plugin on the Grafana marketplace and are now integrated with Grafana Alert Manager. This means engineers can stay in their Grafana dashboards and still benefit from Causely’s causal insights. There is no need to switch tools or chase raw signals. We meet engineers where they already are — but with less noise and more answers.
Most alert systems assume each alert is unique. We know that in real life, a flood of alerts often stems from a single root cause. Causely detects the underlying issue and bundles associated symptoms, drastically reducing noise. And now, teams don’t need to chase 50 alerts—they only need to address the one root cause that triggered them all.
Are you using LLMs or AI behind the scenes?
Causely doesn’t rely on large language models (LLMs) or black-box AI to perform root cause analysis. Our system is grounded in causal inference, specifically using Bayesian networks to model probabilistic relationships between service-level events, metrics, and dependencies in a cloud-native environment.
We start with a curated domain-specific knowledge base of known failure modes — things like queue saturation, dependency lag, or CPU contention. This library is explicitly defined and constantly evolving. When Causely is deployed, we dynamically map the topology of your services and apply that knowledge base to it in real time, generating a causality graph. This graph reflects the most probable root causes based on observed symptoms and inter-service relationships.
Unlike LLMs, which are trained to generate language or summarize content based on vast unstructured data, our system performs abductive inference: given a set of observed anomalies, it infers the most likely explanations using statistical reasoning. That makes the results explainable, repeatable, and mathematically grounded — not just plausible-sounding guesses.
In short: we don’t use AI that generates text — we use AI that understands systems.
So what’s the future of observability, in your view?
The future isn’t more dashboards. It’s more understanding. Teams don’t need more visibility — they need the confidence to know what’s actually going wrong, and why. At Causely, we’re betting that the next generation of observability is causal, probabilistic, and transparent.
Yotam, thank you for sharing your mission with such clarity and passion.
Want to learn how Causely works under the hood?
Check out Causely’s documentation or reach out for a demo — they’re surprisingly open about the math behind the magic.