Maestro by Oteligence · Java Observability

5× deeper traces.
Zero code changes.

Maestro analyzes your compiled JAR, scores your business methods, and generates an 18 KB OTel extension that adds method-level spans at runtime — automatically. No source access. No annotations. No rewrites.

Instrument Your First Repo Free → How it works

✓

OTEL config · all repos free

✓

Instrumentation · first repo free

✓

Java 11–21 · no card

maestro — order-service

$ maestro analyze ◼ Reading bytecode ✓ 247 methods found ◼ Scoring complexity ✓ 5 methods selected ◼ Generating extension ✓ 18 KB ◼ Writing OTEL config ✓ ──────────────────────────────────── COMPLETE order-service · < 2 s ──────────────────────────────────── Instrumented: 5 / 247 methods Span increase: 1 → 5 per request .o11y/ ├─ instrumentation/target/extension-1.0.0.jar ← 18 KB ├─ javaagent.config └─ maestro.config $

5×

More spans per request vs. OTel agent alone

Live test · Spring Boot 3.4 · Jaeger

Lines of application code changed

Extension plugs into OTel Agent Extension API

67%

Estimated MTTR reduction at fleet scale

Method-level bottleneck identification

~30%

Observability platform cost reduction

Precision spans vs. blanket instrumentation

Works With

Java 11–21Spring BootQuarkusMicronautOTel Agent 2.xKubernetesDockerJaegerGrafana TempoPrometheusDatadogNew RelicDynatraceAWS · GCP · Azure Java 11–21Spring BootQuarkusMicronautOTel Agent 2.xKubernetesDockerJaegerGrafana TempoPrometheusDatadogNew RelicDynatraceAWS · GCP · Azure

The Problem

The OTel agent sees your service.
It can't see inside it.

The standard OpenTelemetry Java Agent instruments frameworks — HTTP, JDBC, Kafka. It treats your business logic as a black box. You know an endpoint was slow. You don't know which method.

Span per HTTP request from the standard OTel agent

You see "POST /api/orders took 309 ms" — nothing else. No call hierarchy. No method breakdown. The next step: add debug logging, rebuild, redeploy.

10–30×

Span overhead from blanket @WithSpan on all methods

The naive fix floods APMs with noise, inflates bills 10–30× baseline, and degrades AI anomaly detection — without improving diagnostic quality.

30 min

Average time lost per incident to debug-logging cycles

Add logging → rebuild → redeploy → reproduce → collect → remove. Each cycle: 50–100 GB burst logs at $0.10–$0.25/GB. 50 incidents/month = thousands avoidable.

How It Works

JAR in. Method-level traces out.
Under 5 minutes.

No source code access. No code changes. No new agents. Maestro extends the OTel Java Agent you already run — adding a precise, scored instrumentation layer on top.

Upload your JAR

Drag your compiled JAR into the Maestro UI, or run maestro analyze from the CLI. Source code never leaves your environment — Maestro reads bytecode only. Analysis completes in under 2 seconds.

🔒 Bytecode only · Source never required ⏱ Analysis < 2 seconds

Two paths — same resultquickstart

# Option A: Web UI (no install)
app.oteligence.com → Automatic Instrumentation
Drag .jar → "Upload & Start Analysis"

# Option B: CLI
$ curl -LO https://downloads.oteligence.com/maestro-mac.zip
$ maestro setup # authenticate with API token
$ maestro init # creates .o11y/ folder + GUID
$ maestro analyze # score + generate extension

Scoring selects what matters

The proprietary scoring engine evaluates every method: exception handling, branching complexity, I/O boundaries, and sync blocks. Only high-signal methods make the cut. In a 247-method service, 5 get instrumented.

Automatic: engine decides Manual: browse & select from the file tree

Scoring signalsengine

Signal                 Weight
─────────────────────────────────
Exception handling     high
Branching complexity   high
I/O boundaries         high
Sync blocks            medium
Framework internals    excluded

Result: 5 / 247 selected · 1.3× overhead

Download Extension JAR + Summary

Maestro generates an 18 KB OTel Extension JAR that plugs into the OTel Agent's Extension API. You also receive an HTML Instrumentation Summary — an interactive report with every instrumented class, method, complexity scores, and exact run commands.

18 KB · No new agent required HTML summary with full method breakdown

.o11y/ — generated structuretree

.o11y/
├─ maestro.config ← GUID + org
├─ javaagent.config ← OTel agent settings
├─ dotenv.config
└─ instrumentation/
├─ pom.xml
└─ src/main/java/ ← generated source

$ cd .o11y/instrumentation && mvn clean package

Run with OTel agent — one flag

One -D flag added to your existing startup command. The extension plugs into the OTel Agent Extension API. Oteligence spans appear tagged [oteligence], nested inside HTTP server spans.

Jaeger · Grafana Tempo · Datadog · New Relic

Run commandbash

$ java \
-javaagent:opentelemetry-javaagent.jar \
-Dotel.javaagent.extensions=extension-1.0.0.jar \
-Dotel.javaagent.configuration-file=.o11y/javaagent.config \
-Dotel.service.name=order-service \
-jar your-application.jar

# Traces appear: library.name = [oteligence]

Live Test Results — Jaeger

Same app. Same request.
Radically different visibility.

Spring Boot 3.4 order-processing service. Same JAR, same request, all traces exported to Jaeger via OTel Collector. Every span is from a live test run — Feb 26, 2026.

Before — OTel Agent Only

v2.17.0 · 1 span

TraceID: 0e50ff3b092ce6b4f7a315755c76cc55

POST /api/orders [171.6 ms]
http.response.status_code=201 · http.route=/api/orders

(no child spans — business logic invisible)

Diagnosis: "The order endpoint took 171 ms." Which method? No idea. Next: add debug logging, rebuild, redeploy — generating burst log volume Datadog charges to index.

span total

business methods visible

After — OTel Agent + Oteligence

18 KB extension · 5 spans

TraceID: cfdfbb8a7b05043a84b087d81246596d

POST /api/orders [205.1 ms] http.response.status_code=201

createOrder [163.1 ms] order=3b664029

validateOrder [0.2 ms] order.id=3b664029
calculatePricing [0.6 ms] coupon=SAVE10
processPayment [161.5 ms] order.id=3b664029 ← 98.9% of latency. Found in seconds.

Diagnosis: processPayment() consumed 161.5 ms of 163.1 ms. Payment gateway is the bottleneck. Found in seconds. Zero code changes.

spans total

business methods visible

📊

Span overhead comparison: Oteligence adds 1.2–1.5× baseline span volume. Blanket @WithSpan adds 10–30×. You get 5× more diagnostic insight at a fraction of the ingestion cost. Estimated APM cost reduction: ~30%.

Instrumentation Modes

Let the engine decide —
or you decide.

Both modes produce the same output: an Extension JAR + HTML Instrumentation Summary. The difference is who makes the selection decision.

⚡

Automatic Instrumentation

Recommended for most teams

Upload your JAR. Maestro's scoring engine evaluates every method and selects the highest-signal candidates automatically. No decisions required. Under 2 seconds.

Upload JAR — UI drag-and-drop or maestro analyze

Scoring engine selects methods automatically

Download Extension JAR + HTML Summary

Run with OTel agent — one flag added

Best for	Why
First-time analysis	No setup decisions needed
Unfamiliar JAR	Engine knows what to look for
CLI workflows	Single command, repeatable
Speed	Under 2 seconds, UI or CLI

🔬

Manual Instrumentation

Full control

Browse your JAR's complete package/class/method tree. Search, filter, expand. Hand-pick exactly which methods to instrument — or override what Automatic selected.

Upload JAR → "Upload & Start Exploration"

Browse expandable file tree · search · filter

Check packages, classes, or individual methods

Generate → Download Extension JAR + Summary

Best for	Why
Debug specific method	Pinpoint what you need traced
Override auto selections	Add or remove specific methods
Audit instrumentation	See exactly what will be traced
Complex services	Fine-grained scope control

💡

Pro tip: Run Automatic first for fast coverage. Open the HTML Instrumentation Summary to review what was selected. Use Manual mode to refine on your next iteration.

What Maestro Produces

Three plain files.
No proprietary formats.

Every Maestro output is a standard file you can commit to source control, review in a PR, or pipe into any build tool. No lock-in.

📦

extension-1.0.0.jar

18 KB · OTel Extension JAR

Plugs into the OTel Java Agent via the official Extension API. One -D flag. No new agent, no new infrastructure. Spans appear tagged [oteligence].

-Dotel.javaagent.extensions=extension-1.0.0.jar

⚙️

javaagent.config

Text · OTel agent configuration

Full OTel Java Agent configuration — exporter endpoint, protocol, service name, instrumentation toggles (JDBC, HTTP, JVM metrics, Micrometer, propagators). Managed via the Projects UI. Overwritten on each maestro analyze — do not edit manually.

-Dotel.javaagent.configuration-file=.o11y/javaagent.config

📋

Instrumentation Summary

Interactive HTML · method-level report

Every instrumented class and method, complexity scores, scoring breakdown, and the exact CLI command to run your instrumented application. Generated by both Automatic and Manual modes. Save alongside your extension JAR as permanent documentation.

open instrumentation-summary.html

Pricing

Your first repo instruments free.
Pay when you scale.

OTEL configuration is free for all repos, forever. Full instrumentation — Extension JAR, deeper traces, Instrumentation Summary — is free for your first repo. Pay only when you add a second.

OTEL Config

All repos · forever · no card required

Get Started Free →

✓ Bytecode analysis · all repos

✓ OTEL configuration generation

✓ javaagent.config output

✓ Project configuration UI

✓ CLI access · all platforms

–Extension JAR generation

–HTML Instrumentation Summary

Full Instrumentation · First Repo Free

Instrumentation

$0 / 1 repo

First repo per org · permanently free · full features

Start Instrumenting Free →

✓ Everything in OTEL Config

✓ Automatic Instrumentation mode

✓ Manual Instrumentation mode

✓ 18 KB Extension JAR

✓ HTML Instrumentation Summary

✓ 5× deeper traces · zero code changes

✓ Admin Controls · RBAC · Audit logs

–Additional repos (see Pro)

Pro — Additional Repos

$125/mo

Per repo · $1,500/yr · annual commitment

Or $1,200/yr paid upfront — save $300 per repo

Upgrade →

✓ Everything in Instrumentation

✓ Each additional repo beyond first

✓ Billing dashboard

✓ Priority support

✓ Design partner access (annual upfront)

Repos	Monthly Billing	Annual Upfront	Annual Savings
1 repo	Free	Free	—
2 repos	$125/mo ($1,500/yr)	$1,200/yr	Save $300
3 repos	$250/mo ($3,000/yr)	$2,400/yr	Save $600
5 repos	$500/mo ($6,000/yr)	$4,800/yr	Save $1,200
10 repos	$1,125/mo ($13,500/yr)	$10,800/yr	Save $2,700

ℹ️

What counts as a repo? A unique codebase, identified by a GUID from maestro init. Dev, staging, and production of the same codebase share one GUID — they count as 1 repo, not 3. Need enterprise rollout or SOC 2 support? Talk to Expert Services →

Product Roadmap

What's live, what's next.

No vague "coming soon." Here's exactly where Maestro is today and what we're building — in the order we're building it.

Live Now

Available at app.oteligence.com and via the Maestro CLI today

⚡

Automatic Instrumentation

JAR upload → scoring → Extension JAR + HTML Summary. Under 2 seconds.

🔬

Manual Instrumentation

Browse full package/class/method tree. Hand-pick what to instrument.

📦

18 KB OTel Extension JAR

Plugs into OTel Agent Extension API. No agent replacement. No code changes.

⚙️

Project Configuration UI

Per-project OTel agent settings: exporters, protocols, instrumentation toggles.

💻

CLI — macOS · Linux · Windows

setup · init · analyze · compose — local developer workflow.

👥

Teams & Admin Controls

Organizations, RBAC (Owner/Editor/Viewer), API tokens, audit logs.

Up Next

In active development · Q2–Q3 2026

🎯

Goal-Based Instrumentation

Select Debug Latency, Trace Errors, Business Flow, or General — scoring weights signals for your goal.

🗺️

Call Dependency Graph

Interactive HTML visualization of method call hierarchy derived from bytecode.

🔁

CI/CD Pipeline Integration

GitHub Actions, GitLab CI, Azure DevOps. Auto-analyze on every push.

Roadmap

Planned · prioritized by user demand

💰

Cost Reduction Goal

Enter APM spend + span volume. Maestro models savings specific to your Datadog / New Relic contract.

🟨

JavaScript / Node.js

Scoring engine + extension generation for Node.js. Email us to influence priority.

🐍

Python & .NET

Planned after JavaScript. Email support@oteligence.com to register demand.

FAQ

Engineer questions.
Direct answers.

No. Maestro reads compiled .jar files via bytecode inspection. Your source code never leaves your environment. You upload the same artifact your JVM runs — Maestro analyzes the binary. This works on legacy services where source may not be available, and gives security teams confidence that proprietary logic stays internal.

Automatic — the scoring engine selects methods based on exception handling, branching complexity, I/O, and sync blocks. No decisions needed. Best for first-time analysis, unfamiliar JARs, CLI workflows.

Manual — browse the complete package/class/method file tree. Search, filter, check exactly what to instrument. Best for debugging a specific method, overriding automatic selections, or auditing scope before generating.

Three files:

extension-1.0.0.jar           — 18 KB OTel Extension JAR (drop into agent)
javaagent.config              — OTel Java Agent configuration
Instrumentation-Summary.html  — Interactive report: methods · scores · run commands

Via CLI, these live in .o11y/ alongside maestro.config and dotenv.config. Extension source is generated under .o11y/instrumentation/src/ and built with mvn clean package.

java -javaagent:opentelemetry-javaagent.jar   -Dotel.javaagent.extensions=.o11y/instrumentation/target/extension-1.0.0.jar   -Dotel.javaagent.configuration-file=.o11y/javaagent.config   -Dotel.service.name=your-service   -jar your-application.jar

Oteligence spans appear in Jaeger, Grafana Tempo, Datadog, etc. with library.name = [oteligence], nested as children of the OTel agent's HTTP server span.

Maestro generates extensions targeting Java 11 through Java 21+, working with OpenTelemetry Java Agent v2.x. Framework-aware for Spring Boot, Spring MVC, Quarkus, and Micronaut. Any JVM-based application works — framework awareness provides additional scoring heuristics for those specific patterns.

A repo is a unique codebase identified by the GUID from maestro init, stored in .o11y/maestro.config.

Scenario	Repo count
Same codebase · dev / staging / prod	1 repo (same GUID)
Two different services	2 repos (different GUIDs)
Re-running maestro init (same directory)	1 repo (reuses GUID)
Delete .o11y/ and re-initialize	New GUID = new billable repo

Yes — in two ways:

1. Precision spans replace debug-logging cycles. With method-level traces always present, you eliminate the add-logging → rebuild → redeploy cycle. Each cycle generates 50–100 GB burst log data at $0.10–$0.25/GB. 50 incidents/month = $3,000–$15,000/month in avoidable ingestion cost.

2. Scored instrumentation controls span volume. Oteligence adds 1.2–1.5× baseline. Blanket @WithSpan on all methods adds 10–30×. Estimated APM platform cost reduction at scale: ~30%.

Not yet automatically — CI/CD integration (GitHub Actions, GitLab CI, Azure DevOps) is in active development. Currently the Maestro CLI is designed for local developer use. You can run maestro analyze locally and commit the generated .o11y/ folder so the whole team shares the same extension and config without re-running analysis.

Yes, today Maestro supports Java (Java 11–21+) only. JavaScript/Node.js, Python, and .NET are on the roadmap. Language support is prioritized by user demand — email support@oteligence.com with your requirement to influence what we build next.

5× deeper traces.Zero code changes.

The OTel agent sees your service.It can't see inside it.

JAR in. Method-level traces out.Under 5 minutes.

Same app. Same request.Radically different visibility.

Let the engine decide —or you decide.

Three plain files.No proprietary formats.

Your first repo instruments free.Pay when you scale.