Self-healing observability that auto-fixes bugs without manual setup

Observability tools have long promised to simplify debugging, but most still require weeks of manual configuration before they deliver real value. Frustrated by endless setup and brittle dashboards, two founders set out to build a platform that does the heavy lifting itself—installing telemetry, detecting issues, and even proposing fixes.

Nico and Arseniy, co-founders of Superlog (Y Combinator P26), launched a self-installing observability system that eliminates the most painful parts of monitoring: initial setup, alert fatigue, and post-incident debugging. Their tool doesn’t just collect logs—it actively investigates errors, merges duplicate alerts, and submits pull requests with potential fixes, all without human intervention.

The observability pain points that inspired Superlog

Early-stage teams often avoid investing in observability because tools like Sentry, Datadog, and Grafana demand steep learning curves and ongoing maintenance. Even after setup, developers face three recurring problems:

• Manual instrumentation delays: Adding structured logs and metrics to a growing codebase is time-consuming, and missed instrumentation means missing data when issues arise.
• Alert fatigue: Sentry’s noisy notifications and Dash0’s dashboard clutter create constant interruptions, especially on weekends.
• Inconsistent metrics: Teams waste hours cross-checking AWS dashboards, only to find conflicting data or empty graphs.

"We spent more time configuring tools than actually debugging," Arseniy said, reflecting on his years at Datadog. "The #ops channel on Saturday mornings was always the worst place to be."

How Superlog works: zero-setup, self-healing monitoring

Superlog’s approach flips the observability model by prioritizing automation over configuration. Here’s the workflow:

1. Instant instrumentation: A setup assistant scans your repository and automatically adds OpenTelemetry SDKs, structured logs, traces, and metrics. It respects semantic conventions and tags services by environment, ensuring consistency from day one.

1. Error fingerprinting and grouping: Duplicate alerts are merged into single incidents with clear failure summaries, severity scores, and impact assessments. No more alert storms in Slack.

1. AI-driven investigation: When an issue occurs, the system’s agent analyzes the incident, pulls relevant context from documentation and past investigations, and either:

• Submits a concise, tested pull request with a proposed fix, or
• Posts detailed findings for the team to review.

1. Continuous refinement: A daily agent run updates dashboards, alerts, and logs as the codebase evolves, ensuring new features are automatically instrumented. No manual reconfiguration needed.

# Example of Superlog’s auto-generated instrumentation in a Node.js project
npx superlog init --repo-path ./my-app

Three ways Superlog stands out from traditional tools

Most observability platforms focus on data collection, but Superlog differentiates itself through three core innovations:

1. Eliminates the setup barrier

• No manual SDK configuration or dashboard creation.
• Native OpenTelemetry support with proper service tagging.
• Future-proof dashboards and alerts that update automatically.

2. Prevents telemetry decay

• A daily agent run ensures new code paths are instrumented before issues arise.
• Logs, metrics, and traces remain relevant even as the application grows.

3. Solves alert fatigue with AI

• Incidents are grouped intelligently, reducing noise by up to 90%.
• Pull requests include severity scores and confidence metrics, so engineers know which issues to prioritize.
• Vendor-neutral data retention—logs and metrics stay under your control.

Early user feedback and future roadmap

Superlog is still in its early stages, but the founders are already seeing traction among teams tired of traditional observability overhead. Their pricing model emphasizes simplicity, with no hidden costs for scaling.

The team is actively seeking feedback from developers who:

• Run integration-heavy products
• Have built custom observability solutions
• Struggled with Sentry or Datadog setups

"We’re not just another observability vendor—we’re rethinking the entire workflow," Nico explained. "Our goal is to turn incident response from a fire drill into a controlled, automated process."

As observability tools evolve, the shift from manual to autonomous systems could redefine how teams handle production reliability. Superlog’s approach suggests a future where debugging starts with a pull request, not a late-night alert.