pre-1.0 · building in the open

Answers, instantly Your data stays yours

Correlate logs, metrics, traces, and profiles on one self-hosted data plane, stored as Parquet on your S3.

Deploy for free Live demo

Apache 2.0 · Parquet · Your S3

Quick start

Run the product before you believe the page.

Start Postgres, MinIO, and molesignal standalone, then load built-in cross-signal sample data from the product home.

$ docker compose -f deploy/docker/docker-compose.yaml --profile standalone up -d

Full guide

intake protocols: 9
real-time alert path: <1s
telemetry signal families: 4
open-source license: Apache 2.0

The differentiated workflow

Three signals. One trace_id. Five seconds.

A trace, its logs, and the host metric for the same minute — natively correlated at the data plane, not stitched in a dashboard.

One trace_id, three views.

trace_idabc123· 4 spans · 280ms

POST /api/checkout

db.tx.begin

stripe.charge

db.tx.commit

Same trace_id=abc123 across all three. No copy-paste between tools.

How does this work? →

Real product, not a moodboard

From raw telemetry to a resolved incident.

Explore shipped operator surfaces: APM service health, dashboards, SQL log search, PromQL metrics, traces, browser sessions, Web Vitals, profiling flame graphs, alerting, synthetic monitoring, customer status pages, data pipelines, and governed AI investigations.

Services + transactions + dependencies

See application health before opening a single trace.

Compare throughput, error rate, tail latency, deployments, dependencies, and top backend errors across real services.

MoleSignal APM overview with throughput, error rate, latency, service health, and high-impact dependencies — APM

Why teams switch

The outcomes matter more than the telemetry taxonomy.

molesignal is designed around the jobs platform teams repeat during every incident and every budget review.

Investigate in context

Carry trace, time range, service, and tenant context from a metric to a trace, profile, or exact log event.

Keep the data you need

Put columnar telemetry on your object storage instead of deleting useful data to control a per-GB bill.

Operate one platform

Replace a three-store observability stack with one binary, one metadata layer, and one query plane.

product / shipped

One product surface, fourteen operator capabilities.

Start with the job you need to solve. Every capability shares the same tenant, time, storage, and query context.

Four signal families. One operational context.

Keep logs, metrics, traces, and continuous profiles under one tenant and time model. Columnar telemetry shares one query plane while lossless pprof archives stay portable on object storage.

Understand application health before the next incident.

Turn OpenTelemetry traces into service-level throughput, error, and latency views. Compare transactions, dependencies, errors, and deployments, then open the representative request without rebuilding context.

Keep the production story on one shared canvas.

Compose operational views from the telemetry already in MoleSignal. Organize dashboards by folder and tags, reuse variables, import JSON, and move from any panel into the underlying investigation.

Search every event without losing the incident.

Use structured fields, SQL, distributions, and full-text pruning while trace and time context stay ready for the next drill-down.

See the trend and the telemetry behind it.

Query Prometheus-shaped metrics with PromQL, inspect labels and cardinality, and move from a spike to the responsible service and traces.

Move from service topology to the failing span.

Explore service health, RED metrics, latency distributions, error-first traces, and complete span waterfalls in one workflow.

See what the code was doing when the request slowed down.

Capture CPU, memory, goroutine, and lock profiles across services. Explore flame graphs, call trees, and top functions, then move between a hot frame and its correlated trace or span.

See the user journey that happened before the backend failed.

Connect browser sessions, actions, errors, Web Vitals, and frontend requests to the same trace and time context used by backend telemetry. Reproduce the journey in Session Replay, then continue into the responsible backend span.

Keep the incident together as the question changes.

Move metric → trace → profile or log → host and back while the investigation stack preserves each frame, time anchor, and entity filter.

Detect on the right path. Route with context.

Evaluate SQL on a schedule, match events in the intake path, or use anomaly detectors—then route incidents through policies, rotations, and the channels your team already uses.

Test the customer journey before customers report it.

Run active protocol and browser checks from the Standalone embedded runner or your own private Probe locations. Test every draft, publish a verified revision, and keep schedule, state, and execution evidence connected.

Turn operational truth into customer communication.

Operate public or private status pages without mixing the event archive into the daily workspace. Manage components, incidents, maintenance, subscribers, domains, access, and publication automation from seven focused areas.

Shape telemetry before it becomes storage cost.

Connect real sources, define governed streams, and normalize, enrich, redact, encrypt, or route data before it lands. Monitor every log, metric, and trace pipeline with run history and health state.

Ask the platform. Inspect the evidence. Govern the action.

Use Mole Agent to investigate anomalies across telemetry and operational context. Turn repeatable work into automations, require approval for sensitive actions, and retain a record of every execution.

Explore the product

The differentiated workflow

Follow the failure, not a trail of copied IDs.

The investigation stack keeps each drill-down as a frame, so operators can move forward and back without reconstructing the incident.

101 · Detect
A real-time or scheduled rule fires
Start from the signal that changed, with its organization, service, and time range already attached.
202 · Localize
Open the service path and trace
Move from the metric spike to error-first traces and the span that consumed the latency budget.
303 · Explain
Inspect the logs in the same window
Query correlated events with the trace and time anchor prefilled instead of copying IDs between products.
404 · Act
Acknowledge, route, and resolve
Use escalation policies, rotations, and notification channels while the complete investigation stays available.

Inbound MCP server

Let external AI operate MoleSignal — inside the same controls.

Connect Codex, ChatGPT, or any Streamable HTTP MCP client. Every request is credential-bound, IAM-authorized, filtered by Tool Policy, and audited.

Connect an MCP client Explore the tool model

Streamable HTTP

MCP endpoint/api/v1/mcp

01
AI client
Codex · ChatGPT · any MCP host
02
Credential
OAuth 2.1 · personal or service token
03
Authorization
Inbound surface ∩ IAM ∩ Tool Policy
04
Controlled execution
Confirmation · approval · idempotency · audit

Progressive tool discovery

tool_search

Find tools available to this credential.

call_read_tool

Run bounded reads and side-effect-free preflight.

call_managed_tool

Run governed changes through the required policy.

Server-enforced boundaries

Workspace identity comes from the credential, never model arguments.
190 registered tools without a 190-tool context dump.
Risk policy decides automatic, confirmation, single-, or dual-approval execution.

Plug in the stack you already run

OpenTelemetry first. Drop-in paths when migration matters.

Send OTLP directly, keep Prometheus remote_write, accept Loki or Elasticsearch-shaped traffic, and store the result on the object store you control.

OTLP gRPC

OTLP HTTP

OTLP Profiles

pprof upload

Pyroscope-compatible intake

Prometheus remote_write

Elasticsearch _bulk

Loki push

Native HTTP JSON

AWS Kinesis Firehose

Cloudflare Logpush

Heroku Log Drain

See all integrations

Under the interface

One storage layer. One query engine. One tenant boundary.

Parquet on object storage, DataFusion and Arrow for query, Tantivy for pruning, and Postgres for metadata. The implementation is visible because the architecture is part of the product promise.

Read the architecture

Economic proof

Compare the operating model, not just a feature checklist.

Commercial SaaS, a stitched OSS stack, and molesignal shift cost and operational work in different ways. The assumptions stay visible and testable.

Dimension	Commercial SaaS Datadog / New Relic / Splunk	OSS stack Loki + Mimir + Tempo	molesignal self-hosted
100 GB/day cost	~$2k+/mo · grows linearly	infra only	infra only
Three signals — same storage Whether logs, metrics, traces share one storage layer.	✓ (their cloud)	3 stores, 3 query langs	Parquet + DataFusion
Cross-signal correlation Jump from a trace to its logs to the host metric — without copy/paste.	✓ (paid)	manual trace_id copy-paste	native (/web/correlation/*)
Data ownership	their cloud	self-hosted	self-hosted

100 GB/day cost

Commercial SaaS: ~$2k+/mo · grows linearly
OSS stack: infra only
molesignal: infra only

Three signals — same storage

Whether logs, metrics, traces share one storage layer.

Commercial SaaS: ✓ (their cloud)
OSS stack: 3 stores, 3 query langs
molesignal: Parquet + DataFusion

Cross-signal correlation

Jump from a trace to its logs to the host metric — without copy/paste.

Commercial SaaS: ✓ (paid)
OSS stack: manual trace_id copy-paste
molesignal: native (/web/correlation/*)

Data ownership

Commercial SaaS: their cloud
OSS stack: self-hosted
molesignal: self-hosted

1updated 1mo ago

Star on GitHub

Show support and stay in the loop. The repo is the project's source of truth and the fastest way to file an issue.

Join our Discord

Chat with design partners and contributors. Click to join our community space.

Open-source observability

proof / shipped

What the public product includes today.

The open-source repository is the product, not a thin agent feeding a closed backend.

Logs, metrics, traces, continuous profiles, dashboards, and service views
RUM sessions, errors, Web Vitals, source maps, and Session Replay
Cross-signal correlation and investigation stack
Scheduled, real-time, and anomaly alerting

design partner

Be early. Be heard.

We're recruiting 5–15 mid-size teams to help shape v1. Weekly founders chat. Real influence on the product. Free.

Become a Design Partner Join waitlist