Another open-source observability tool that’s truly serious this time — they’ve gone all in. The pain of having monitoring data locked in by SaaS vendors? Anyone who’s lived through it knows. :https://github.com/monoscope-tech/monoscope…

Meet Monoscope: three hardcore features that deliver. Logs, traces, and metrics all go into your own S3 bucket — data sovereignty in your hands, no vendor protection fees. Query data directly with natural language, backed by an LLM — no more memorizing user-hostile query syntaxes. AI agents patrol on a schedule to catch anomalies and automatically email you when issues are found. Native OpenTelemetry with 750+ integrations, real-time log streaming. Self-hosters will love it. Keep an eye on this one.

monoscope-tech/monoscope

Source: https://github.com/monoscope-tech/monoscope

Open-source observability platform with S3 storage

Ingest and explore logs, traces, and metrics stored in your S3 buckets. Query with natural language. Create AI agents that detect anomalies and send daily/weekly reports to your inbox.

GitHub Release (https://github.com/monoscope-tech/monoscope/releases) License Haskell (https://www.haskell.org/) Discord (https://discord.gg/BSFCaUHxt4)

Website (https://monoscope.tech) • Playground (https://app.monoscope.tech/p/00000000-0000-0000-0000-000000000000/log_explorer) • Discord (https://discord.gg/BSFCaUHxt4) • Twitter (https://x.com/monoscope-tech) • Documentation (https://docs.monoscope.tech)

What is Monoscope? • Cloud vs Self-hosted • Quick Start • AI Agents • Roadmap

What is Monoscope?

Monoscope is an open-source observability platform that stores your telemetry data in S3-compatible storage. Self-host it or use our cloud offering (https://monoscope.tech).

Core capabilities:

• 💰 S3 storage — Store years of logs, metrics, and traces affordably in your own S3 buckets
• 💬 Natural language queries — Search your data using plain English via LLMs
• 🤖 AI agents — Create agents that run on a schedule to detect anomalies and surface insights
• 📧 Email reports — Receive daily/weekly summaries of important events and anomalies
• 🔭 OpenTelemetry native — 750+ integrations out of the box
• ⚡ Live tail — Stream logs and traces in real-time
• 🕵️ Unified view — Correlate logs, metrics, traces, and session replays in one place

Cloud vs Self-hosted

In both options, you bring your own S3 buckets—your data stays yours.

→ Start free on Cloud (https://monoscope.tech) or continue below to self-host.

Quick Start

bash git clone https://github.com/monoscope-tech/monoscope.git cd monoscope docker-compose up

Visit http://localhost:8080 (default: admin/changeme)

Send Test Data

Populate your dashboard with test telemetry: ``bash monoscope auth login

Single event — see your message appear in the dashboard

monoscope send-event -m “Hello from Monoscope”

Sustained load — stress-test the pipeline

monoscope telemetrygen –kind=trace –rate=5 –count=50 ``

CLI

Manage your Monoscope project from the terminal — search logs, query metrics, manage monitors and dashboards, triage issues, and more. bash curl https://monoscope.tech/install.sh | sh monoscope auth login See the CLI reference for the full command list.

Agentic pipeline

Every CLI command emits a stable JSON envelope, so you can chain discovery → search → triage without manual munging. This is the same pipeline a Claude Code skill runs end-to-end: ``bash

1. What services exist? (Precomputed; no aggregation query needed.)

SVC=$(monoscope facets resource.service.name –top 1
| jq -r ‘.[“resource.service.name”][0].value’)

2. Grab one error event from that service — id only, ready to chain.

ID=(monoscope logs search 'severity.text=="error"' \ --service "SVC“ –first –id-only)

3. Pull the surrounding 5 minutes of traffic, with a per-trace summary

showing which other services were affected.

monoscope events context –window 5m –summary
–at “(monoscope events get "ID” | jq -r .timestamp)“
| jq ‘.traces | sort_by(-.error_count) | .[0:3]’

4. Acknowledge the open issue once you have a hypothesis.

monoscope issues list –service “$SVC” –status open
| jq -r ‘.data[].id’ | head -3
| xargs -I {} monoscope issues ack {} ``

Each step’s output shape is documented and stable:

Set MONOSCOPE_AGENT_MODE=1 (or run with --agent) to force JSON output and disable interactive prompts — auto-detected when CI or CLAUDE_CODE is set.

Claude Code Skills

Let Claude investigate incidents, triage alerts, and write KQL queries using the monoscope CLI — install the skills plugin: ``bash

Claude Code

claude plugin marketplace add monoscope-tech/skills claude plugin install monoscope-skills@monoscope-skills

or via npx (Cursor, Cline, Copilot, and other agents)

npx skills add monoscope-tech/skills `` Restart Claude Code after installation. Skills activate automatically when relevant — e.g. “investigate the 500 errors in payment-api” or “do an on-call sweep”. See github.com/monoscope-tech/skills (https://github.com/monoscope-tech/skills) for the full skill list and documentation.

MCP Server

Monoscope exposes itself as a Model Context Protocol (https://modelcontextprotocol.io/) server at /api/v1/mcp, so any MCP-aware client (Claude Desktop, Cursor, Cline, custom agents) can search events, manage monitors and dashboards, triage issues, and run composite workflows like search_events_nl (natural-language → KQL) and analyze_issue (LLM-assisted root-cause). json { "mcpServers": { "monoscope": { "url": "https://api.monoscope.tech/api/v1/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } Every public REST endpoint is auto-registered as a verb-first tool (list_monitors, search_events, mute_monitor, …). See the MCP reference for the full protocol, tool catalog, and examples.

Integration

Auto-instrument your apps

Python bash pip install opentelemetry-distro opentelemetry-exporter-otlp opentelemetry-bootstrap -a install OTEL_SERVICE_NAME="my-app" \ OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317" \ opentelemetry-instrument python myapp.py Node.js bash npm install --save @opentelemetry/auto-instrumentations-node OTEL_SERVICE_NAME="my-app" \ OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317" \ node --require @opentelemetry/auto-instrumentations-node/register app.js Java bash curl -L https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar -o otel-agent.jar OTEL_SERVICE_NAME="my-app" \ OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317" \ java -javaagent:otel-agent.jar -jar myapp.jar Kubernetes ``bash

Install OpenTelemetry Operator

kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml

Configure auto-instrumentation

kubectl apply -f - <<EOF apiVersion: opentelemetry.io/v1alpha1 kind: Instrumentation metadata: name: monoscope-instrumentation spec: exporter: endpoint: http://monoscope:4317 EOF

Annotate your workloads

kubectl annotate namespace default instrumentation.opentelemetry.io/inject-java=“true” ``

Natural Language Queries

Query your telemetry data in plain English:

• “Show me all errors in the payment service in the last hour”
• “What caused the spike in response time yesterday?”
• “Which endpoints have the highest p99 latency?”

AI Agents & Reports

Create AI agents that monitor your systems on a schedule:

• Scheduled analysis — Agents run at intervals you define (hourly, daily, weekly)
• Anomaly detection — Automatically surface unusual patterns in logs, metrics, and traces
• Email reports — Receive summaries of important events and insights directly in your inbox
• Customizable focus — Configure agents to watch specific services, error types, or metrics

Architecture

mermaid graph LR A[Your Apps] -->|Logs/Metrics/Traces| B[Ingestion API] B --> C[TimeFusion Engine] C --> D[(S3 Storage)] D --> E[Query Engine] E --> F[Dashboards] D --> G[AI Agent Scheduler] G -->|LLM Analysis| H[Anomaly Detection] H --> I[Email Reports] H --> J[Alert Channels]

Project Structure

Monoscope is organized into four primary components:

• app/ — Haskell server binary (WAI/Yesod web application)
• cli/ — Command-line interface for managing projects, querying data, and automating workflows
• web-components/ — Custom UI elements (Web Components) for dashboards and log exploration
• src/ — Core Haskell library exporting shared types, utilities, and business logic

Powered by TimeFusion

Monoscope is built on TimeFusion (https://github.com/monoscope-tech/timefusion), our open-source time-series database for observability workloads.

How It Compares

Screenshots

Log Explorer - Unified View

Logs and trace spans displayed together in context for complete observability.

Trace Context Integration

See detailed trace information alongside logs for debugging complex distributed systems.

Dashboard Analytics

Real-time metrics and performance monitoring with AI-powered insights.

Trusted by Leading Companies

“Monoscope notifies us about any slight change on the system. Features that would cost us a lot more elsewhere.” — Samuel Joseph, Woodcore

Documentation

• Getting Started Guide
• CLI Reference
• MCP Server
• Configuration
• Kubernetes Guide
• Development Guide

Roadmap

• Custom dashboards builder
• More out-of-the-box dashboards
• AIOps workflow builder
• Full migration to TimeFusion storage engine
• Metrics aggregation rules
• Multi-tenant workspace support
• More alert channel integrations

See our public roadmap (https://github.com/monoscope-tech/monoscope/projects) for details and to vote on features.

Community

💬 Discord (https://discord.gg/BSFCaUHxt4) • 🐛 Issues (https://github.com/monoscope-tech/monoscope/issues) • 🐦 Twitter (https://x.com/monoscope-tech)

License

AGPL-3.0. See LICENSE for details. For commercial licensing options, contact us at [email protected].