JeraViz
DocumentationGet Started

Agentic AI observability

Every AI execution.
Fully understood.

JeraViz gives engineering teams the visibility to trace, inspect and understand every step their AI agents take — from model requests and tool calls to decisions, errors and execution costs.

Start for FreeExplore the Platform

JeraViz Trace is in development. The dashboard below is an interactive preview using illustrative sample data.

env: sampleLast 24hIllustrative data

Overview

DegradedFailure rate 4.97% is above the 4% threshold

Executions

4,812

▲ 6.2%vs prev. 24h

Successful

4,573

95.0%

Failed

239

▲ 1.1 pts4.97%

Latency p95

8.9 s

avg 3.6 s · p50 2.4 s

Tokens

29.6M

24M in · 5.6M out

Est. cost

$40.40

≈ $0.0084 / run

Executions over time

hourly

23:00 · 80 runs · 5 failed

025050000:00 · 67 runs · 2 failed01:00 · 53 runs · 2 failed02:00 · 47 runs · 2 failed03:00 · 40 runs · 1 failed04:00 · 47 runs · 2 failed05:00 · 67 runs · 2 failed06:00 · 120 runs · 5 failed07:00 · 187 runs · 8 failed08:00 · 254 runs · 11 failed09:00 · 307 runs · 14 failed10:00 · 348 runs · 16 failed11:00 · 374 runs · 18 failed12:00 · 361 runs · 17 failed13:00 · 374 runs · 19 failed14:00 · 388 runs · 20 failed15:00 · 361 runs · 19 failed16:00 · 321 runs · 17 failed17:00 · 267 runs · 15 failed18:00 · 214 runs · 12 failed19:00 · 174 runs · 10 failed20:00 · 147 runs · 9 failed21:00 · 120 runs · 7 failed22:00 · 94 runs · 6 failed23:00 · 80 runs · 5 failed00:0006:0012:0018:0023:00
SuccessfulFailed

Agent activity

24h
  • triage-agent$5.05

    4,812 runs · 0.25% failed · p95 2.1 s

  • retrieval-agent$11.31

    4,266 runs · 0.89% failed · p95 4.8 s

  • refund-agent$24.04

    2,104 runs · 8.98% failed · p95 8.1 s

Recent traces

Select a row
StatusTraceAgentDurationCost
Successrefund-agent6.42 s$0.0133
Failedrefund-agent11.2 s$0.0132
Successretrieval-agent2.31 s$0.0057
Failedretrieval-agent4.82 s$0.0004
Successrefund-agent3.98 s$0.0133
Failedrefund-agent4.12 s$0.0108
Successtr_8f3a21ticket-resolution
Duration
6.42 s
Spans
12
Tokens
9,870
Est. cost
$0.0133
payments_api.create_refund
Kind
Tool call
Status
OK
Start
+4.70 s
Duration
640 ms

{ "order_id": "ord_20418", "amount": 64.00 }

The operational intelligence layer for AI agent systems.

AI agents are becoming more autonomous, but understanding their decisions, execution paths, tool interactions and failures is still hard. JeraViz brings that activity into one inspectable platform.

Today: evidence in four places

  • Model provider dashboard

    Request ids, token counts, no workflow context

  • Application logs

    Strings per service, no parent–child structure

  • Tool API logs

    503 at 14:29:46, which agent caused it?

  • Spreadsheet of costs

    Monthly total, not per execution or step

With JeraViz: one execution record

  1. ticket-resolution 6.42 s
  2. triage-agent 1.37 s
  3. classify-ticket 1.15 s
  4. retrieval-agent 1.88 s
  5. vector_search 560 ms
  6. refund-agent 3.12 s
  7. payments_api.create_refund 640 ms

One execution record: every model request, tool call and handoff in order, with latency, tokens and estimated cost on each step.

Illustrative sample trace.

Four ways to see inside an agent.

Each capability works from the same execution record, so what you trace is what you analyze, debug and monitor.

01

Agent Tracing

Follow every execution from beginning to end.

  • Execution → trace → span hierarchy
  • Model requests, tool calls and agent handoffs on one timeline
  • Search and filter across execution history
  • Launch scopeTrace explorer and timeline
tr_8f3a216.42 s12 spans3 agents
  • ticket-resolution
  • triage-agent
  • classify-ticket
  • retrieval-agent
  • vector_search
  • kb_lookup
  • synthesize-context
  • refund-agent
  • plan-refund
  • orders_api.get_order
  • payments_api.create_refund
  • compose-reply
Illustrative data

02

Execution Analytics

Understand latency, usage and cost across agent workflows.

  • p50 / p95 / p99 latency per workflow, agent and tool
  • Token usage and estimated cost per execution
  • Estimates are labelled as estimates
  • Launch scopeCore analytics
  • PlannedPer-agent comparisons
p502.4 s
p958.9 s
p9917.6 s
Est. cost$40.40
  • triage-agent$5.05
  • retrieval-agent$11.31
  • refund-agent$24.04

Estimated cost by agent, last 24 hours (sample).

Illustrative data

03

Intelligent Debugging

Inspect model interactions, tool calls and execution failures.

  • Jump from a failed execution to the failing span
  • Arguments, results and error categories on every tool call
  • You see what was recorded; JeraViz does not guess intent
  • Launch scopeSpan inspector
  • PlannedDedicated tool, model and error views
  1. ticket-resolution
  2. refund-agent
  3. payments_api.create_refund

tool_timeout

Timed out after 5000 ms waiting for payments-api

Arguments

{ "order_id": "ord_20418", "amount": 64.00 }

Timed out after 5.00 s; retried once, then escalated (sample).

Illustrative data

04

Agent Monitoring

Identify unusual activity, failures and reliability issues.

  • Project health states with the rule shown
  • Threshold alerts on failure rate, latency and usage
  • Anomaly notifications against a learned baseline
  • Launch scopeHealth and trends
  • PlannedAlerts
  • RoadmapAnomaly detection

23:00 · failure rate 6.3%

0%5%10%threshold 4%00:0006:0012:0018:0023:00
Rule (concept)

Alert when failure rate in production exceeds 4% over 15 minutes.

Concept · illustrative data

Three views. One execution record.

Operate the preview: every view reads the same sample dataset, so the failure you find in the explorer is the one you follow in the graph and see in the analytics.

Find the failing runs, then read the trace.

Filter executions, open one, and follow the span hierarchy of model requests and tool calls with durations on a shared timeline.

  • Toggle “Status: failed” and “Agent: refund-agent”.
  • Select a span to inspect its arguments, error and cost.
  • Use the arrow keys to move between spans.
support-copilot · sampleIllustrative data
8 of 8 executions
StatusExecution IDAgentStart (UTC)Duration
Successrefund-agent14:32:086.42 s
Failedrefund-agent14:29:4111.2 s
Successretrieval-agent14:27:152.31 s
Failedretrieval-agent14:24:524.82 s
Successrefund-agent14:21:303.98 s
Failedrefund-agent14:18:074.12 s
Successrefund-agent14:15:447.90 s
Successretrieval-agent14:12:192.77 s
Failedtr_c91d07refund-agent
Spans
13
Model
4
Tools
5
Tokens
9,870
Cost
$0.0132
payments_api.create_refund

tool_timeout Timed out after 5000 ms waiting for payments-api

Kind
Tool call
Status
Error
Start
+4.70 s
Duration
5.00 s

Arguments

{ "order_id": "ord_20418", "amount": 64.00 }

From first line to first trace.

Four steps from connecting an application to improving it. The code shown is illustrative; the SDK is in development.

  1. Connect your AI application

    Add the SDK (or point an OpenTelemetry exporter at JeraViz) and a project API key. No change to your agent architecture.

    SDK · OTLP · API key

    # illustrative
install the SDK

jeraviz.init(api_key=…)

  2. Capture execution events

    Model requests, tool calls and handoffs are recorded as spans and sent in the background, so instrumentation does not block your agent.

    Async · batched · fail-open

    {
  "trace_id": "tr_8f3a21",
  "span": "payments_api.create_refund",
  "kind": "tool",
  "agent": "refund-agent",
  "status": "ok",
  "duration_ms": 640,
  "args": { "order_id": "ord_20418" }
}

  3. Inspect traces and behavior

    Open any execution to see the timeline, inputs, outputs, errors, tokens and estimated cost for each step.

    Timeline · inspector · filters

    refund-agent
    plan-refund
    orders_api.get_order
    payments_api.create_refund

  4. Improve performance and reliability

    Find the slow or failing step, fix it, and watch the trend change. Evaluations to lock in gains are on the roadmap.

    Analytics · alerts (planned) · evals (roadmap)

    failure rate over timeillustrative shape, no real data

Built for the way agents are actually built.

Six common system shapes and what JeraViz records for each. These describe what can be instrumented through the SDK or OpenTelemetry; no framework integration is claimed here.

  • planactobserveloop until stop

    Autonomous AI agents

    Agents that plan, act and observe in loops until they decide to stop.

    • Each iteration as a span
    • Decisions and stop reason
    • Loop count, cost and duration
  • ››

    Multi-agent workflows

    Several agents delegating to one another.

    • Handoff edges between agents
    • Per-agent latency and cost
    • Failure origin across agents
  • requestmodelresponse

    LLM applications

    Request, model, response: the simplest and most common shape.

    • Prompts and completions (capture mode permitting)
    • Tokens, latency, finish reason
    • Estimated cost per call
  • args → resultretry on error

    Tool-using agents

    Agents that call APIs, databases and functions.

    • Tool arguments and results
    • Retries and timeouts
    • Error category per call
  • queryretrievere-rankgenerate

    RAG applications

    Retrieval, re-ranking and generation pipelines.

    • Retrieval spans and result counts
    • Context size sent to the model
    • Empty-retrieval failures
  • triggerhumanrecord

    Enterprise AI workflows

    Triggers, agents, human steps and systems of record.

    • End-to-end execution record
    • Human-wait time as its own span
    • Outcome and cost per workflow

Instrumentation you can read in one screen.

Add a few lines, keep your architecture. Every tool call and model request becomes a span you can search and inspect.

  • SDK integration Launch scope

    Python and TypeScript SDKs with decorators, context managers and automatic batching.

  • API access Launch scope

    REST API and OpenTelemetry (OTLP/HTTP) ingestion for anything you can instrument.

  • Documentation Launch scope

    Concepts, quickstart and reference. Starter docs are on this site now.

  • API keys Launch scope

    Keys scoped to a project and environment; shown once, stored hashed, revocable.

  • Project management Launch scope

    Projects and environments separate applications and stages such as staging and production.

  • Integration examples Planned

    Worked examples for common agent shapes. Framework adapters follow the first release.

  • Developer onboarding Launch scope

    A guided first run that ends with your first trace, plus a sample-data mode.

Developer overview 
# Illustrative: not a published SDK
import jeraviz

jeraviz.init(
    api_key="YOUR_API_KEY",
    project="support-copilot",
    environment="staging",
)

@jeraviz.agent("refund-agent")
def handle_refund(ticket):
    # Each tool call becomes a span with arguments, result, duration and errors.
    with jeraviz.tool("payments_api.create_refund", args={"order_id": ticket.order_id}) as call:
        result = payments.create_refund(ticket.order_id)
        call.set_result(result)
    return result
Illustrative example. The JeraViz SDK is in development; names and signatures may change. Not a published package.

After your first event: open the trace in the dashboard, inspect each span, and compare runs.

Designed for isolation, auditability and scale.

The proposed data flow and the principles behind it. Statuses are explicit: these are design principles for the first release, not audited controls.

  1. 01AI ApplicationSDK or OpenTelemetry exporter
  2. 02Telemetry IngestionAuthenticated, validated, rate-limited
  3. 03Event ProcessingNormalize, price tokens, apply privacy rules
  4. 04Trace StorageColumnar event store + object storage
  5. 05AnalyticsRollups, percentiles, cost
  6. 06JeraViz DashboardExplorer, timeline, analytics
Proposed architecture. Illustrative diagram, not a description of a running system.

  • Secure data transmission

    Launch scope

    TLS for public endpoints; project-scoped API keys on ingestion.

    By design

  • Workspace isolation

    Launch scope

    Every record is scoped to a workspace; enforced in application code and database policy, and tested.

    By design

  • Access controls

    Launch scope

    Role-based access at workspace level (owner, admin, developer, viewer).

    By design

  • Encryption

    Launch scope

    Encryption at rest with managed keys for databases, object storage and queues.

    By design

  • Auditability

    Planned

    Administrative actions are recorded from the start; a user-facing audit log follows.

    Recording at launch, UI planned

  • Data retention

    Launch scope

    Retention set by plan; deletion on request; per-project capture modes limit what is stored.

    Per-project retention planned

Pricing that follows your execution volume.

Three tiers, shaped by execution volume, retention, projects, team size and advanced capabilities.

Proposed pricing architectureLimits are proposals and no prices are set. Final terms will be confirmed before launch.

Developer

Individual developers and experimentation.

Free tier

Proposed

Executions
~10,000 / month
Trace retention
7 days
Projects
2
Team members
1–2
  • Tracing, timeline and inspector
  • Core analytics
  • Sample-data mode
  • Community and docs support
Start for Free

Team

Growing AI engineering teams.

Subscription + usage

Price to be announced

Executions
~100,000 / month, then metered
Trace retention
30 days (extended option)
Projects
~10
Team members
~10 included
  • Everything in Developer
  • Advanced filtering and saved viewsPlanned
  • Agent graph, tool, model and error viewsPlanned
  • Alerts and monitoringPlanned
  • Email support
Join the early-access list

Enterprise

Larger organizations with advanced requirements.

Custom

Contact us

Executions
Committed volume
Trace retention
1 year or custom
Projects
Custom
Team members
Custom
  • Everything in Team
  • SSO / SAMLPlanned
  • Audit log exportPlanned
  • Governance (Guard) add-onRoadmap
  • Dedicated tenancy optionsFuture
Contact us
  • All limits are proposed and may change before launch.
  • Overage: the Developer tier would stop accepting new executions at its cap; Team would bill per 1,000 executions up to a spend cap you set. Your application is never affected either way, because SDKs fail open.
  • Costs shown in the product are estimates from token counts and a price table, not invoices.
Compare every dimension

Questions engineers ask first.

Cannot find what you need? Ask us directly.

Contact us

Build agents with visibility. Operate them with confidence.

Understand what your agents do, identify what needs improvement and build more reliable AI systems with JeraViz.

Start Building with JeraVizRead the docs

JeraViz Trace is in development. Sign-up is not open yet; the early-access page explains where things stand.