Changelog

This week we made your agents' work easier to share and act on. Links from Axiom MCP now open the exact result your agent returned or the resource it built, and two new skills let agents send data to Axiom. We also shipped a way to see whether your notifiers deliver, new Amp and ChatGPT notifiers, Microsoft Teams alerts as Adaptive Cards, clickable labels, and views in Terraform.

Share and act on your agent's work

When an agent investigates or builds something in Axiom through the Axiom MCP server, you now get a link to exactly what it did. Open it yourself, or send it to a teammate.

• Links that show what the agent saw: Ask your agent to save or share a query result, or to give you a link to it. Axiom stores that result, and the link opens the exact result the agent returned instead of running the query again. Everyone who opens it sees the same rows the agent based its answer on, and opening it adds no query cost. Saved results are kept for 6 hours, after which the link runs the query again. Only people who can read every dataset in the query can open a saved result. Console shows a notice when you're looking at one, and Run gets you fresh data.

• Links to what the agent builds: When an agent creates or updates a dataset, monitor, notifier, or dashboard, the result ends with an Open in Axiom link to that resource. You can check what the agent built in one click.

• Let your agent send data: Two new Axiom skills let your agent send data to Axiom, even if you don't have an organization yet. axiom-ingest picks an organization from your config, creates the dataset, sends JSON, NDJSON, or CSV, and checks the event count with a query. If no organization is set up, axiom-create-org creates a temporary one and gives you a link to claim it within 24 hours.

• Built-in instructions: Every session starts with instructions that tell the agent when to use Axiom and how to find the right dataset and field names before it queries, so fewer queries fail on guessed field names.

• Latest protocol: The hosted server supports the 2026-07-28 version of the Model Context Protocol alongside the session-based version. Existing setups keep working.

For more information, see Axiom MCP Server and Agent-created orgs.

See whether your notifiers deliver

A monitor is only useful if its alert reaches someone. Open a saved notifier in Console to see a Deliveries section with the last 7 days of sends. Each row shows whether the send was delivered or failed, which monitor fired it, whether it was a trigger or a resolve, the HTTP status, and the error text when something went wrong. A Failing badge marks a notifier whose recent deliveries fail and tells you when it last succeeded.

• Problems on the monitor: The notifiers panel on a monitor shows when a notifier is disabled or missing in red, and paused in amber. Select View notifier to open it and fix it.

• Errors you can act on: Failed deliveries explain what went wrong and what to fix in plain language, with hints for common Slack and Discord errors. Webhook URLs, which can contain secrets, stay out of these messages.

• Email when a notifier is disabled: If repeated failures disable a notifier, Axiom emails its creator and last editor, or the organization's owners and admins, with the last error and a link to fix it.

• Test both ends: Test notifications now send a resolve about 10 seconds after the trigger.

For more information, see Notifiers.

Send monitor alerts to Amp and ChatGPT

Amp joins Cursor and Claude Code as a notifier type for coding agents. In Amp, set up a plugin that registers a webhook. Then create an Amp notifier in Axiom and paste the webhook URL. When the monitor fires, Axiom sends the monitor summary to Amp. Axiom stores the webhook URL encrypted.

You can also send alerts to a published ChatGPT workspace agent: create a ChatGPT notifier with the agent's API channel ID and an access token with the Workspace Agents scope.

Clickable labels, and views in Terraform

Labels on datasets, dashboards, monitors, and notifiers are now clickable. Click a label in a list to add it to your active label filters. Your other filters and the match mode stay as they are, and clicking a label doesn't open the row.

You can also manage labels and views as code:

• Labels: Terraform provider v1.8.0 adds an axiom_label resource for a label's name, description, and color, with import support. Assign labels to dashboards, monitors, and datasets with a labels set on each resource.

• Views: Terraform provider v1.9.0 adds an axiom_view resource. A view is a saved query over your datasets that you use like a dataset, for example to share a filtered slice of your data. Define a view's name, APL, and description next to the datasets and roles that use it, and import existing views by name.

For more information, see Labels, Views, and Terraform.

More of our favorite changes

• Microsoft Teams alerts as Adaptive Cards: Axiom now sends Microsoft Teams alerts as Adaptive Cards, which work with Teams Workflows webhooks. Each card shows the monitor name, status, description, and labels, with View monitor and Resolve monitor buttons. You don't need to change your notifier.

• Service map and statistics for traces: Traces have two new views. The service map shows every service a trace passed through and every call between them. The statistics view sums up a trace in one table, grouped by service, span name, span kind, or status. Read the full announcement in Service map and statistics for traces.

• OTLP metrics from a base URL: Axiom accepts OTLP metrics at /v1/ingest/<dataset>/v1/metrics. Tools that take only a base endpoint and add /v1/metrics themselves, such as Render, can send metrics to https://<edge-domain>/v1/ingest/<dataset> with an ingest token.

• Trace view shortcuts: Press a number key to switch trace views, for example 1 for the waterfall and 2 for the conversation view of a trace with AI spans. The view menu shows each view's key.

Service Map and Statistics views are now available for Traces in Axiom.

While the traditional Waterfall view presents a complete view of every span of a trace, it is not always the best way to represent large traces. These new views allow you to quickly understand the shape of a trace, and see aggregated information about performance and errors.

See how a request moved through your system

The service map shows every service a trace passed through and every call between them.

Databases, queues, and external hosts appear too, even when they aren't instrumented: Axiom finds them in the client spans of the services that call them.

Find where the time went

The statistics view sums up a trace in one table. Group spans by service, span name, span kind, or status, then by a second field, and compare counts, errors, total and average duration, and self time. Select a row to see its spans and correlate back to the waterfall.

Critical Path is now available in Axiom's trace viewer.

For any slow trace, it is usually only a small subset of spans that contribute to its slowness. The critical path is the chain of spans the trace waited on. Speed up any of them and the whole trace gets faster.

Highlight the critical path

Open a trace, then open the Critical path menu in the waterfall toolbar and select Highlight critical path. Every span bar dims, and the parts of each span that held up the trace are drawn in full color.

Show only spans on the path

Select Show only spans on the path to hide every span that isn't on the critical path. In large traces with hundreds or thousands of spans, it can be difficult to see what the key spans are. By showing only the critical path, you can focus on the spans that determine the total duration.

Built for real traces

The algorithm used for Axiom's critical path is based on CRISP, the algorithm Uber built to find critical paths in its production traces. We improved it with better handling of concurrency, and better handling of cases where spans are slightly mis-timed, which often happens in distributed systems.

For more information, see Traces.

It's been a while since our last roundup, so this one is big. We shipped monitor alerts that go straight to Cursor and Claude Code, a one-paste way to connect your coding agent to Axiom MCP, search for spans and fields inside any trace, and one editor for every monitor type. Dashboard charts get threshold lines, and you can find and delete stale fields in bulk.

Alert Cursor and Claude Code from monitors

When a monitor fires, you can now hand the problem straight to a coding agent. Two new notifier types, Cursor and Claude Code, send a monitor summary to a Cursor automation or a Claude Code routine. Add the automation's webhook URL or the routine ID along with a token, and Axiom does the rest. Create these notifiers in Console or through the API.

Every alert also carries more context now: a monitor's labels travel with its alerts to Slack, Microsoft Teams, Discord, webhooks, and Cursor and Claude Code. Custom webhook templates can use them through .Labels.

Connect agents to Axiom MCP with one paste

The Axiom MCP server gives your coding agent direct access to your datasets, dashboards, and monitors. To connect it, open the MCP menu in Console and select Copy setup prompt. Paste the prompt into Claude Code, Codex, OpenCode, Devin Desktop, GitHub Copilot in VS Code, Cursor, or another coding agent. The agent registers the hosted Axiom MCP server and signs you in with OAuth. You don't run any commands and you don't need an API token.

Once it's connected, your agent can do more than before:

• Open in Axiom: Query results include an Open in Axiom link that reopens the same APL or MPL query in Console with the same dataset, parameters, and time range.

• Manage labels: Resources come back with their labels, and the listLabels, manageLabels, and setLabels tools let an agent create, rename, and delete labels and tag resources.

• More tools: Agents can create datasets, inspect dataset metadata and fields, read annotations, look up monitors, discover metric tags, search the Axiom docs, and work across several organizations in one session.

Find spans and fields inside any trace

Large traces can hold thousands of spans. Press Cmd+F on Mac or Ctrl+F on Windows and Linux in the trace viewer to open a find panel. Step through matches one by one, turn on case-sensitive matching, and choose what to search: everything, span name, service, or any field path. Find also works in the GenAI conversation view, so you can jump to the message you're looking for in a long agent run.

Reading timing is easier too. Hover the timeline and a time cursor follows your pointer through every row, showing the offset from the start of the trace and the time of day. Waterfall rows are more compact, so more of a trace fits on screen.

One editor for every monitor type

Creating a monitor now starts with a card for each type: threshold, match, or anomaly. Switch types in place without losing your work. Every type uses the same editor as dashboard elements, with the query, a plain-language summary of the threshold settings, and a live preview chart in one column. Notification, evaluation, and label settings sit in a collapsible sidebar.

• Notifiers in place: Notifiers appear as a list you can add to, edit, or detach, and you can create a new notifier without leaving the monitor.

• Notify on resolve: Threshold and anomaly monitors have a Notify on resolve switch, so you choose whether you hear about recoveries.

• Back on in one click: Disabled monitors show a banner with a one-click way to turn them back on.

• No dead ends: When you reach your monitor limit, the editor offers a way to upgrade or contact sales.

Threshold lines on dashboard charts

A chart tells you more when you can see where "too high" starts. Add threshold lines to dashboard time-series charts in the chart editor, and they appear every time the dashboard loads. For counts and sums, you can set a threshold as a rate, such as 10 per second, and Axiom adjusts the line to the chart's bin size, for example drawing it at 300 when each bin covers 30 seconds.

The chart editor itself has more room. The query workspace sits in the center with a compact settings inspector beside it, the preview looks exactly like the element on your dashboard, and you can switch an element between chart types without starting over.

Find and delete stale fields in bulk

Fields that stop receiving data still count toward your field limit. Fields with no data in the last 30 days now carry a STALE badge in the dataset's field list.

To clean up, open the Fields menu and select Delete fields. Type a pattern to find matching fields, uncheck the ones you want to keep, or choose Check all stale to select exactly the stale ones. Deleting fields also vacuums the dataset, so there's no separate cleanup step.

More of our favorite changes

• API tokens: API tokens open in a full-width table you can search, filter, and sort by owner, creation date, last use, or expiry. Each token shows when it was last used, broken down into ingest and other API calls. Expired tokens appear with a clear label, and tokens that expire within seven days show a warning. Groups also open in a full-width table that shows each group's name, description, users, and roles.

• Query cost limits: Org admins can cap hourly and daily query spend on API tokens and roles, and see live usage against each limit.

• Access control as code: Terraform provider v1.7.0 adds axiom_role, axiom_group, axiom_user_role, and an axiom_users data source. You can also import existing roles and groups.

• MPL offsets: Use offset to compare a metric with its own past values, for example week over week. Offsets work in both directions: offset -1h reads an hour earlier and offset +1h reads an hour later. Unlike in PromQL, an unsigned offset looks forward.

• OpenTelemetry metrics as JSON: The OTLP metrics endpoint accepts JSON as well as Protobuf, so you can send metrics with the http/json protocol from browser, serverless, and scripting runtimes.

• Metrics datasets: Trim metrics datasets and edit their retention just like event datasets. You can also see usage broken down by metric and chart rejected points on the dataset page.

• Dashboard actions: Clone a dashboard, copy its link, or delete it from the dashboard page itself. Integration dashboards offer Fork instead of Clone.

• Chart colors: Pick the 24-color Polychrome palette and assign colors by series name, so the same series keeps its color across charts.

• Dashboard refresh: Turn auto-refresh off and use a manual refresh button instead.

• Related data: OTel datasets that aren't part of a correlation show a Related data banner that suggests one.

• Search highlighting: Search matches are highlighted in the monitors, datasets, and other resource lists.

• GenAI costs: Cost estimates for GenAI spans, evals, and the Generative AI Overview dashboard price cached input tokens correctly.

• Axiom for Splunk: Version 1.4.0 lets Splunk Enterprise Security search OCSF data in Axiom as Splunk CIM, and version 1.3.2 adds a traces view with waterfalls and GenAI conversation views.

Labels give your Axiom organization a shared way to organize datasets, dashboards, monitors, and notifiers. Group related resources by team, service, environment, or project so they are easier to find.

Organize resources your way

Create labels such as env=production, service=payments, or team=platform, then assign them to the resources they describe. Reuse the same labels across resource types to keep your organization consistent. Each label has a color and an optional description to help your team recognize it and understand when to use it.

Assign or remove labels from a resource’s Labels menu, or set them while creating or editing a dataset, dashboard, or monitor.

Find related resources faster

Use the Labels section in each resource list’s sidebar to filter the list. Select several labels and choose ANY to match at least one, or ALL to match every selected label. Counts next to each label reflect the page’s other active filters.

Label filters stay in the page URL, so sharing a filtered list preserves your selection.

Give agents better context

Axiom’s Model Context Protocol (MCP) server exposes label names and descriptions alongside resource metadata. Agents use that context to understand which service a resource belongs to, which environment it covers, and which team owns it.

For example, an agent investigating payment errors uses env=production and service=payments to identify relevant datasets, dashboards, and monitors. A team=platform label adds ownership context. Label descriptions explain what each group of resources is for, helping the agent choose where to query data and which existing dashboards and monitor definitions to inspect.

After selecting a dataset, the agent uses its fields or metric tags to build queries.

Manage labels in one place

Open Settings > Labels to create labels, edit their names, descriptions, and colors, or see how many resources use each label. Changes to a label’s definition apply everywhere it is assigned.

For more information, see Labels.

The command menu brings search, navigation, and everyday actions together in Axiom Console. Open a dataset, jump to a dashboard or monitor, or look up a trace by ID from one menu.

Commands adapt to the page you’re viewing. Run a query, change a dashboard’s time range, or pause a live log stream. Settings, theme controls, and documentation are also a few keystrokes away.

Press ⌘K on Mac or Ctrl +K on Windows and Linux, then start typing. Use the arrow keys to select a result and Enter to open it or run an action.

An AI agent can now stand up a real Axiom organization on its own, work in it immediately, and hand it to a human to keep. Alongside that: multi-query charts for every query type, sortable legends and heatmap colors, zoomable traces, a new in filter for metrics, and a batch of improvements to the Axiom MCP server.

Agent-created organizations

An AI agent can now create a real Axiom organization on its own, with no signup and no human in the loop, then start working in it right away: creating datasets, ingesting and querying data, and building dashboards and monitors. It behaves like any other organization, not a sandbox.

The organization starts out temporary and lasts 24 hours. The agent gets back a claim link; open it, sign in, and the organization becomes permanently yours, with everything the agent built intact. Leave it unclaimed and it’s removed at the 24-hour mark. Until it’s claimed, the organization runs on a short-lived footprint (up to 10 GB of ingest and 1 GB-hour of query compute, notifiers paused, three organizations a day); claiming lifts those to the full Personal plan.

Point your favorite agent at the agent-created organizations documentation to get started.

Chart legends and heatmap colors

Borders, corner radii, dividers, and empty states around charts, query results, aggregation tables, and the Stream tab now come from one shared chart frame, so panels line up with each other wherever they appear. On top of that:

• Aggregation columns in legends: Line and bar chart legends can show Last, Mean, Min, Max, Total, and Count columns for each series, so the numbers you’d otherwise hover for sit right next to the series.

• Sort legends by any aggregation: Legends sort by the first aggregation by default. Click any aggregation in a right-side legend to sort ascending or descending by it; both right-side and bottom legends get a control to sort by any aggregation in either direction.

• Bottom legends stay compact: A bottom legend holds its height to three rows and scrolls past that, so a high-cardinality series list keeps its hands off the plot area.

• Higher contrast in dark mode: Axis labels and legend text in dark mode now carry the contrast light mode already had, which makes a dense time series easier to read across the room.

• A color for heatmaps: Dashboard heatmaps gain the same Color setting statistic charts have, and cell values render as a continuous opacity gradient in that color rather than a fixed set of steps.

• One refresh per dashboard: Auto-refresh runs every chart on a dashboard through a single batched request on one timer, so a refreshed dashboard is one consistent snapshot rather than a set of charts that each arrived at their own moment.

More ways to build charts

• Multi-query and dual Y-axis for every query type: Multiple queries on one chart and a secondary Y-axis used to be metrics-only. They now work for structured, APL, and MPL queries alike, each query row with its own builder-or-editor mode and its own validation, so you can overlay related series and put two units on one chart whatever query wrote them.

• Switch a chart’s type in place: A type picker in the chart editor moves a chart between time series, statistic, table, log stream, and the rest without recreating it, and keeps its limit, sort, and aggregation settings across the change.

• Size metrics charts: Metrics queries get the same chart sizing controls as everything else on a dashboard.

Zoom into traces

• Zoom and pan the waterfall: The trace timeline is now interactive: drag to select a range, use the mini-map, wheel-zoom, zoom to a span, or reset back out.

• Honest gaps in the timeline: The event timeline in the Query tab dims the stretches where there are no events, so a gap reads as a gap rather than evenly spread data.

• Markdown in annotations: Chart annotations render markdown, so a note on a spike can carry a link or a bit of structure. The Show annotations toggle also stays put on the query event timeline.

Query smarter with APL and MPL

• An in filter for metrics: MPL queries take a where … in [a, b, …] membership filter, with array values and array query parameters, so matching a tag against a set is one clause instead of a chain of ors.

• top after summarize in APL charts: APL dashboard charts allow | top following summarize, so you can rank an aggregation directly in the chart’s query.

• Aggregation queries return more rows: A query ending in summarize returns a narrow result: its aggregations and group-by keys. Axiom now sizes the row limit to those columns instead of the limit it reserves for a query projecting every field, so many aggregations that used to stop at 50k rows now return more.

• Metrics query warnings surface: Warnings from an MPL query now show in the results banner, and a query whose aggregation changes a metric’s unit (like map rate) shows a unitless Y-axis.

The Axiom MCP server

• Dashboard sections: The dashboard tools understand sections, so an agent can create and edit dashboards that group charts into sections instead of one flat grid.

• Correlation groups in listDatasets: listDatasets reports which datasets are correlated, so an agent knows which datasets it can join across before it writes a query.

• The APL skill loads inline: The axiom-apl reference skill now loads into the session that asked for it, not a subagent, so its APL syntax is on hand the moment a query gets written. Install it with npx skills add axiomhq/skills.

More of our favorite changes

• The Where, Summarise, and sort-by field pickers now show a type icon and label (String, Number, or Timestamp) next to every option.

• Each metric in an OpenTelemetry metrics dataset shows its unit, and the block visualization can list a dataset’s metrics as a table.

• Changing an organization’s default retention lists the datasets it affects and asks you to confirm before a reduction takes effect.

Dashboard sections are now available in Axiom.

Sections group related dashboard elements under a shared header. Use sections to divide a large dashboard. Each section expands and collapses independently. When you collapse a section, Axiom stops running queries for the elements inside it. Expand the section to load the elements again.

Organize dashboard elements

Create a section from the Add element menu, then add new dashboard elements directly to it. Drag existing elements into a section, move elements between sections, or reorder entire sections.

Dashboard elements that aren't assigned to a section remain above the sections. Filter bars also remain outside sections so they continue to apply across the entire dashboard.

Expand and collapse sections

Collapse a section to hide its dashboard elements and stop their queries. Expand the section to load the elements and run their queries again.

Axiom remembers each viewer's expanded or collapsed sections in their browser. Dashboard editors also set whether a section starts expanded or collapsed by default.

Manage sections safely

Rename and reorder sections as the dashboard evolves. When deleting a section, keep its dashboard elements outside all sections or remove the section and its elements together.

For more information, see Dashboard sections.

Gauge dashboard elements are now available in Axiom.

Gauges compare a single numeric value with color-coded segments. Use them to show whether a current value, such as request latency or an error count, is within an expected range.

Set ranges directly

Enter exact boundary values above the segment rail, or drag the boundary handles. Split a segment with the scissors control. Merge adjacent segments with the remove control below their shared boundary.

For a row-based view, expand Edit segment values. Enter the From and To values for each segment, or use Split segment and Remove. The editor keeps segments ordered and contiguous.

Configure the display

Choose a color scale from green to red or from red to green. Display evenly spaced interval labels, exact segment boundaries, or no labels. Add custom units to the value, and enable the sparkline to show how the value changed over time.

Scale thresholds with time

For count and sum gauges, changing the dashboard time range also changes the expected total. Enable Scale to time range to adjust the segment boundaries in proportion to the selected time range. Leave it disabled to use absolute segment values.

Create gauges with Builder or APL

Gauge queries return one numeric series. In Builder, use one aggregation and leave Group by empty. In APL, use a summarize or count statement and group only by _time when displaying a sparkline.

For more information, see Gauge.

This week we shipped dataset schema locking, cut the console’s boot payload by 40%, made smart filters and natural-language queries work without hand-written boilerplate, and gave dashboards proper view and edit modes.

Dataset schema locking

One of the best things about Axiom is that datasets are schemaless: you send whatever your services produce and the fields appear automatically, with no schema to design, migrate, or maintain up front. Sometimes, though, you want the opposite — a dataset whose shape you can rely on, so a status field that has always been an integer stays that way, and the dashboards, monitors, and saved queries built on it keep behaving as expected.

Now you can pin a dataset to its schema. On any event dataset, open the fields panel overflow menu and choose Lock schema. While a dataset is locked, ingest keeps flowing — events still arrive and are counted — but fields that aren’t part of the declared schema are dropped instead of being written, and Axiom reports exactly what it set aside in the ingest response. The panel title reads Fields (Locked) so the state is always clear, and Unlock schema is one click away.

Schema locking isn’t offered for shared datasets or datasets fed by an app integration such as Cloudflare Logpush, Vercel, or Netlify, since those manage their own fields.

A faster console

We spent the week making the console lighter and quicker, measured against production builds with real data.

• A lighter first load: The console now ships around 40% less JavaScript on initial load, so pages become interactive sooner. The win is biggest on the query page, where the query engine now loads on demand the moment you open the editor.

• Smoother long sessions: Working in Axiom for hours at a time is now easier on your CPU and battery, with steadier live streaming and snappier interactions throughout the day.

Smarter query editing

• Smart filters now work with APL and MPL: Previously, using a dashboard smart filter from the editor meant hand-writing a declare query_parameters (APL) or param (MPL) block. Now the variables are surfaced in autocomplete and the required declaration is added for you at query time, so a filter change just works.

• A rebuilt natural-language-to-query experience: Generating a query from a prompt is now an agentic, streaming flow. Instead of one prompt-and-response, the assistant lists your datasets, inspects their schema, validates its draft, and streams its progress back to you — and it now generates MPL as well as APL.

Dashboards get view and edit modes

Dashboards now open in view mode by default: charts can’t be moved, edited, or deleted by accident, and changing the time range applies only to your current session without marking the dashboard as unsaved. Switch to edit mode for a dedicated toolbar with explicit Add element and Save dashboard actions, and an unsaved-changes prompt if you try to leave mid-edit. Sharing a link with a custom time range now seeds that range for the viewer instead of nudging them toward saving a change they didn’t make.

A more useful query timeline

The event timeline on the Query tab picked up two upgrades. Annotations from your dataset now render directly on the timeline for the query’s time range, so deploys and incidents line up with the events you’re reading. And the timeline is now linked to the results table: a violet band marks the time span of the rows currently in view and tracks your scrolling, a hatched region shows where the query match limit truncated results (with an explanation on hover), and you can drag the band to scrub the table.

More of our favorite changes

• Weighted aggregations in APL: New sumw(expr, weight) and countw(weight) functions give you accurate weighted sums and counts over sampled data.

• Complete inner-join results: Inner joins now match against the full right-hand side, so counts and matches reflect every matching row, with no 50,000-row cap.

• The dataset overview page gained a Dataset information panel (name, kind, edge deployment URL, retention, and usage) and a Monitors panel listing the monitors watching that dataset.

• Added a scatter chart, plus a clearer span duration heatmap.

This week the Axiom data source for Grafana learned to speak APL and MPL, APL picked up four new weighted aggregations, the Axiom MCP server gained monitor and notifier management, and metrics datasets get a Kubernetes dashboard the moment the data arrives.

APL and MPL in the Grafana data source

The Axiom data source for Grafana now runs both APL and MPL queries. Previously the plugin spoke a legacy APL-only query shape; the new version shares a single v2 query model across both languages and migrates your saved queries for you.

• Query in APL or MPL: Write APL for logs, traces, and events, or MPL for metrics, with CodeMirror language support in the panel editor.

• Grafana-native results: Query results come back as Grafana data frames, with dedicated builders for time series, log lines, traces, tables, and logs-volume panels, so results render the way Grafana expects.

• Template variables: APL and MPL variable queries now drive dashboard variables, including dataset, metric, and tag-value selectors.

• Fits your Grafana setup: The plugin supports newer Grafana releases and React 19, and honors your configured Grafana HTTP client options rather than its own transport.

Update to the latest version of the Axiom data source to pick these up. If you query an edge deployment, there is now a documented migration path for the edge URL and credentials.

Four new weighted aggregations in APL

APL gains weighted variants of four aggregations: histogramw, variancew, stdevw, and topkw. They join the existing percentilew and avgw, so the full set of weighted aggregations is now available end to end.

A weighted aggregation takes a value and an integer weight that stands in for a repetition count. This is useful when each row already represents many observations, such as pre-aggregated counters, and you want the statistics computed as if the underlying events were expanded. Rows with a weight of 0 or less are skipped, and a missing weight defaults to 1.

More of Axiom for your AI agents

The Axiom MCP server now covers alerting, not just querying.

• Monitor and notifier management: New tools let an agent create, update, and delete monitors, and list, update, and delete notifiers, so an agent can set up an alert and its delivery in one flow.

• Richer metrics discovery: The listMetrics and searchMetrics tools now return each metric's type, temporality, and unit, which helps agents compose correct queries the first time.

Axiom is also now available as an official Grok plugin. The plugin bundles the hosted MCP endpoint and Axiom's skills together, so grok plugin install axiom wires up both at once.

Prebuilt dashboards for Kubernetes and your integrations

Integration dashboards are now generated from your dataset schema instead of a fixed server response, which means they show up automatically for the data you actually send. There are templates for Vercel, AWS Lambda, Cloudflare Logpush, Cloudflare Workers, Convex, OpenTelemetry traces, Tailscale, Next.js, and Netlify.

Dynamic dashboards now understand metric-backed templates too. Send Kubernetes kubelet stats to a metrics dataset and Axiom builds a Kubernetes Stats overview dashboard for it, no manual assembly required.

More of our favorite changes

• Search inside trace logs: In the trace view, the search box now filters the correlated logs, with a toggle to match the log message only or all attributes.

• Activity panel on events datasets: The dataset detail page shows total event count and a chart of ingest activity over a time range you choose, in the right sidebar.

• Metrics in smart filters: A dashboard smart filter's options can now be driven by an MPL metrics query, not just APL.

• Axiom on AWS Marketplace: You can now purchase Axiom through AWS Marketplace. Link your AWS account from the usage and billing page to buy and manage compute credits through your existing AWS agreement.

Correlations are now available in Axiom.

Correlations connect the logs, traces, and metrics that describe the same system. Instead of treating each signal as a separate silo, Axiom lets you move from the first clue to the surrounding system state without manual query stitching.

Move from logs to traces

In many incidents, the first clue is a log event: a timeout, an exception, a failed request, or some local detail that proves something went wrong.

With Correlations, a log event that includes trace context can open the matching trace in Axiom. No copying trace IDs. No switching datasets. No rebuilding the time range by hand.

Inspect related metrics

A trace can show where one request slowed down. It cannot always show whether the service was already unhealthy.

With Correlations, Axiom can surface related workload metrics while you are inspecting the span. That context helps separate a single bad request from a broader service problem.

For more information, see Correlations.

This week is a big one for Axiom. We've made metrics generally available. Axiom now stores and queries logs, traces, metrics, and events in one platform.

Metrics are production-ready

Metrics are now generally available. MetricsDB applies the same architecture Axiom already uses for logs, traces, and events: object storage, ephemeral compute, and no active time series limits. Track every container, service instance, and GPU. The cost model doesn't penalize you for it. Ingest is billed per GB, the same model as everything else you send to Axiom, with no active series count to manage.

Metrics integrate fully with dashboards and monitors, and are queryable alongside your logs, traces, and events in one platform.

MPL (Metrics Processing Language) ships alongside the GA release as a public preview feature. It's a pipeline-based, code-first query language built for time-series operations, designed to be readable by humans, composable by AI agents. Metrics are queryable through Axiom MCP server and a dedicated metrics skill from day one.

For more information, see the full announcement.

Multiple metrics queries in dashboards and Canvas

Dashboard charts can now combine multiple metrics queries into a single time series visualization. Each query can be assigned to a primary or secondary y-axis, making it straightforward to overlay metrics with different scales, like request count and p99 latency, on the same chart. The query preview tooltip, explore, and create monitor actions all work with multi-query charts out of the box.

We've also added a new Include zero values option for y-axis scaling. Previously, chart axes always fit to data. Now you can pin the y-axis to zero for a more accurate visual baseline.

Metrics queries are now fully supported in Canvas as well, bringing the same multi-query and visualization capabilities to ad-hoc exploration.

Revamped metrics dataset summary view

The dataset summary page for metrics datasets has been substantially improved. You can now see an ingest usage chart for your metrics dataset with a configurable date range, browse your metrics in a virtualized list with search, filter by metric type using the dropdown, and jump directly into a query for any metric. Metric type icons in the list make it easier to distinguish gauges, counters, histograms, and summaries at a glance.

Faster page loads with persistent caching

Axiom now persists some frequently accessed data. This means that navigating to dashboards, datasets, monitors, and other pages feels snappier. When you refresh the page or return after a short break, Axiom displays cached data immediately and refreshes it in the background if it's stale. This replaces the previous client-side caching with a more comprehensive and reliable approach.

More of our favorite changes

• Improved scroll behavior and rendering performance in the Stream tab.

Last week, we introduced the Dashboards API and logical AND/OR operators in the metrics builder.

Dashboards API

The Dashboards API gives you full programmatic control over dashboards in your Axiom organization. Previously, dashboards could only be created and managed through the UI. Now you can build, update, and tear down dashboards as part of automated workflows, infrastructure-as-code pipelines, or multi-tenant setups where each customer or team gets their own dashboard on provisioning.

The API exposes five operations:

• List all dashboards

• Retrieve dashboard

• Create dashboard

• Update dashboard

• Delete dashboard

AND/OR operators in the metrics builder

The metrics query builder now supports logical and and or filter operators, making it possible to express the same combinations of conditions that MPL already supported at the query level. You can now combine filter conditions more precisely. For example, filtering for spans where both a status code and a service name match, or where either of two conditions holds true.

More of our favorite changes

• Metrics datasets now show a data usage column in the datasets list, making it easier to see how much data each metrics dataset holds at a glance

Last week we've added the Write Evaluations skill for AI agents and made significant performance improvements to how Axiom renders query results, improved trace viewing for long-running traces, and enhanced the review experience in AI Engineering.

Write Evaluations skill for AI agents

In case you've missed it: we've launched a dedicated AI engineering toolkit, a lens over generative AI machine data built for teams shipping AI products. Alongside rich telemetry and AI-native trace visualization, the toolkit now includes a full evaluation framework: offline evals to catch regressions before you deploy, and online evals to score live production traffic continuously.

The Write Evaluations skill builds on that foundation. It turns AI agents into evaluation suite authors for AI capabilities. Install it in Claude Code, Cursor, Amp, Codex, or any compatible agent. Your AI assistant can then discover available evaluations, compose and execute evaluations against Axiom's AI Engineering dataset, and iterate on results, all from natural language prompts like "Write an evaluation for the support agent's message categorization function."

Install all Axiom skills at once:

npx skills add axiomhq/skills

For agent-specific setup instructions, see the documentation.

Faster event rendering

We've made significant performance improvements to how Axiom renders query results. Event rows now render up to 4x faster, computed results and the events table are more responsive, and full-page re-renders no longer trigger on simple search parameter changes.

These improvements are most noticeable when exploring large result sets or working with datasets that have many fields.

Smarter trace viewing for long-running traces

Previously, trace span loading used a fixed ±1-hour time window, which meant spans in traces longer than two hours could be missed entirely. Axiom now uses an adaptive approach: it starts with the fast ±1-hour window for immediate results, then simultaneously checks a wider 24-hour window. If additional spans are found, the view updates automatically.

This means you can now view complete traces that span up to 24 hours without any extra steps — especially useful if you're running long AI pipelines or batch processing workloads.

More of our favorite changes

• Monitor types on the empty state placeholder are now clickable, navigating directly to monitor creation with the selected type.

• Numeric column headers in query results are now right-aligned for better readability.

• Field selections in the query results table now persist across queries.

• Dashboards default to dark theme in Axiom Playground.

This week we've added support for online evaluations in AI engineering workflows, shipped major upgrades to metrics dashboards and the query canvas, and made API token management significantly easier.

Online evaluations for AI engineering

Previously, evaluations only ran offline against curated test cases with expected outputs. You could catch regressions before deploying, but had no way to continuously score quality once your capability was live.

Online evaluations let you score your AI capability's outputs on live production traffic. Import onlineEval from the Axiom AI SDK and call it inside withSpan. Each evaluation creates OTel spans linked to the originating generation span, so you can trace scores back to the request that produced them.

Because there's no ground truth for live traffic, online evaluations use reference-free scorers that only see input and output. Write boolean scorers for pass/fail checks, numeric scorers for graded scoring, or async LLM-as-judge scorers for deeper quality assessment.

For more information, see the Online evaluation documentation and the blog post.

API token presets

Creating API tokens with the right permissions used to mean toggling individual capabilities one by one. Token presets let you pick a predefined permission set that matches common use cases, then customize from there. This cuts down the time it takes to set up tokens for ingestion, querying, or admin workflows.

GenAI dataset in Playground

We've added a new GenAI dataset in the Playground. This dataset contains a collection of GenAI traces that you can use to explore and understand the GenAI data in Axiom.

You can find the new dataset in:

• The Datasets tab of the Playground

• The automatically created GenAI dashboard in the Dashboards tab

Placeholder configurator component

The documentation just got smarter. Previously, you had to manually rewrite placeholders such as AXIOM_DOMAIN in code snippets. We've now added a configurator component below code examples that you can use to replace placeholders and copy code that's tailored to your specific environment.

To try it out, open a documentation page with a code example and start replacing placeholders using the configurator component.

Smart features for blog and changelog

We now support RSS feeds for the blog and the changelog. You can subscribe to the feed by clicking the RSS icon in the top right corner of the blog or changelog overview pages.

You can also filter changelog items by labels such as New feature, Improvement, or Bug fix, so you can easily find changes related to a specific feature or bug fix.

See these smart features in action in the blog and changelog overview pages.

More of our favorite changes

• Added fit-columns-to-width mode for the events table, so data columns fill exactly 100% of the viewport width without horizontal scroll

• <kbd>Ctrl</kbd>+<kbd>Click</kbd> now works on monitor list rows to open in a new tab

This week we've added support for features that allow you to turn your AI coding agents into metrics exploration experts with the Query metrics skill, query your data within its edge deployment, and send your data to non-US edge deployments from Vercel, Cloudflare Logpush, and Netlify.

Query metrics skill for AI agents

The Query metrics skill turns AI coding agents into metrics exploration experts. Install it in Claude Code, Cursor, Amp, Codex, or any compatible agent. Your AI assistant can then discover available metrics, explore tags and tag values, compose and execute queries against Axiom's MetricsDB, and iterate on results, all from natural language prompts like "Query the CPU usage metric from the app.metrics dataset."

Install all Axiom skills at once:

npx skills add axiomhq/skills

For agent-specific setup instructions, see the Query metrics skill documentation.

Edge query

Query results now stay entirely within your selected edge deployment. Previously, queries executed in your edge deployment but results were routed through Axiom's centralized US infrastructure. Now, both query execution and results remain within the same edge deployment where your data is stored. This means event data is ingested, stored, and queried without ever leaving your selected region.

This is especially important for organizations with data-sovereignty requirements. Frameworks that require both storage and processing to take place within a designated region are now fully supported without needing additional transfer mechanisms.

Edge deployment support for Vercel, Cloudflare Logpush, and Netlify integrations

Vercel, Cloudflare Logpush, and Netlify integrations now support all edge deployments. Previously, these integrations only supported the US East 1 (AWS) edge deployment. The integrations now send data to your organization’s default edge deployment automatically, without any additional configuration.

Search results in aggregation tables

You can now use Cmd+F (or Ctrl+F) to search results in aggregation tables, not just event rows. Previously, this key combination triggered the browser native search feature which could fail on virtualized tables.

More of our favorite changes

• Added checks to make managing capabilities more reliable

Over the past weeks, we've shipped several improvements to make exploring and managing your data in Axiom even smoother. Highlights include smarter APL autocompletions, enhanced field sorting by frequency, and more intuitive API token management.

Sort fields by frequency

The fields sidebar now lets you sort fields by how frequently they appear in your query results. Previously, fields were always listed alphabetically, which made it difficult to quickly identify the most relevant fields in datasets with hundreds of columns. Switch to "Most common" sorting and Axiom ranks fields by presence, showing the percentage of events that contain each field.

Smarter APL autocompletions

Writing in() expressions in APL just got easier. The editor now offers value completions when you type inside an in(...) clause, matching the autocomplete experience you already know from == and contains operators. Start typing a value and Axiom suggests matching field values from your dataset, reducing typos and speeding up query construction.

Improved API token management

API tokens now show who created them and when, making it easier to audit and manage tokens across your team. Each token displays the creator's name and a relative timestamp, with full date details available on the token detail page. A new user filter at the top of the list defaults to showing your own tokens, so you can quickly find what you need.

Quantile support in the metrics query builder

The metrics query builder now supports bucket transformations for histogram metrics, including quantile calculations. When working with histogram-type metrics, Axiom automatically selects the right bucket function and lets you configure quantile values directly in the builder. This brings powerful distribution analysis to the visual query experience without needing to write APL.

Deprecation of the /explorer URL

The https://app.axiom.co/ORG_ID/explorer URL of the Console is now deprecated in favor of https://app.axiom.co/ORG_ID/query. If you have bookmarks, saved links, or integrations that point to /explorer, update them to use /query instead. A redirect is currently in place so existing links continue to work, but we plan to remove the redirect in the future.

More of our favorite changes

• You can now filter by field values directly from the Stream event sidebar, matching the filtering experience already available in the Query tab.

• Consolidated the billing page by merging credit balance information into the Compute credits section with clearer column labels.

• Dashboard aggregation tables are now virtualized, improving scroll and resize performance for charts with many rows.

• Initial page loads are faster thanks to local caching of dataset metadata and early prefetching of user settings.

We've released user feedback capture for AI engineering, made it easier to visualize metrics data, and added support for exporting query results in formats that work better with your workflows.

User feedback for AI engineering

You can now capture user feedback on your AI capabilities and link it directly to traces. When a user gives a thumbs up, leaves a comment, or abandons a response, that signal is stored as a timestamped event connected to the exact AI run that produced it. This lets you correlate user perception with system behavior to understand what went wrong and prioritize high-impact improvements.

Axiom AI SDK supports multiple feedback types including thumbs up/down, numeric ratings, boolean responses, free-form text, and implicit signals like copying or regenerating responses. Feedback events are stored in a dedicated dataset and can be analyzed in both the Query tab and the AI engineering tab.

To learn how to capture user feedback, see User feedback.

Dashboard generation for metrics datasets

You can now generate dashboards directly from metrics datasets. Previously, AI-powered dashboard generation only worked with logs and traces datasets. Now, when you select a metrics dataset, Axiom automatically detects the dataset kind and generates appropriate visualizations for your metrics.

The generation process is intelligent about chart selection. It uses heatmaps for latency, duration, and size metrics while choosing time series charts for counters, rates, and gauges. The result is a dashboard that makes sense for your specific metrics without requiring manual configuration.

We've improved the metrics experience in many other ways:

• Added last aggregation function to the metrics query builder's using clause

• Fixed heatmap rendering issues

• Fixed chart options interface

• Allowed deletion of metrics datasets

• Improved value formatting to include units

TOON export for query results

Query results can now be exported in TOON format, a structured data format that's more efficient when sharing data with LLMs and other tools. Choose TOON (structured) for hierarchical data or TOON (list) for flat representations, depending on what works best for your use case.

For more information, see Export query.

Seamless APL to query builder translation

Switching between APL and the visual query builder is now seamless. Previously, translating complex APL queries to the builder could fail or produce incomplete results. The new translation engine properly handles filters with nested groups, operator precedence, string operations, summarize clauses, ordering, and limits.

Improved chart rendering

We've fixed several chart rendering issues that affected data visibility and accuracy:

• Log scale charts: Values of 1 are now properly visible on logarithmic scale charts. Previously, these values appeared nearly invisible due to how the y-axis minimum was calculated.

• Scatter charts: Fixed a rendering error that occurred when scatter charts had null x-axis data.

• Heatmap labels: Heatmaps now limit the number of labels displayed to prevent visual clutter.

Canvas supports builder queries

Canvas previously only worked with APL queries. You can now use it with builder queries too, bringing the same powerful visual exploration to your analytics workflows. The canvas automatically validates chart types against your builder configuration and preserves your queries in the URL for easy sharing. Whether you're building complex aggregations or simple filters, Canvas now adapts to your preferred query style.

More of our favorite changes

• Improved ingestion reliability with smarter retry limits to prevent cascade failures during high load

• When you copy or download query results as JSON, Axiom now automatically strips null values from the output.

• Reserved datasets are now protected from accidental editing or deletion

Exploring your data often means running multiple queries and comparing results across different views. Previously, you had to either switch between query results or build a full dashboard to see multiple charts together. Canvas changes that.

We’ve also added an expert Site Reliability Engineering (SRE) investigator skill for AI coding agents.

Canvas: A free-form workspace for visual analysis

Canvas is a new tab in the query builder that lets you display multiple charts side by side for quick visual correlation and comparison. Instead of building a full dashboard, Canvas provides a lightweight, free-form workspace where you can add charts as you explore your data.

When you run a query and want to see it alongside other charts, press <kbd>Cmd/Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Enter</kbd> to add the chart to Canvas. You can drag and rearrange charts, change chart types, and compare periods without leaving your exploration flow.

Canvas is designed for quick, ad-hoc analysis. When you’re ready to save your work, you can add any chart directly to a dashboard. This makes it easier to iterate on queries and visualize relationships between different datasets before committing to a persistent dashboard.

Canvas is currently in public preview. For more information, see the documentation.

SRE skill: AI-powered investigation

We’ve built the SRE skill that brings hypothesis-driven methodology and systematic triage to your debugging workflows.

The SRE skill helps AI agents investigate incidents, perform root cause analysis, and troubleshoot production issues by querying your Axiom data. It uses proven SRE methods like the Golden Signals and USE/RED frameworks to guide investigations, and includes a memory system that learns from past debugging sessions to improve over time.

The skill activates automatically for incident response, log investigation, and production troubleshooting. You can also seed it with your own knowledge (team contacts, Slack channels, common failure patterns) to make investigations more contextual and relevant to your environment.

For more information and installation instructions, see the documentation.

We've been busy adding support for API token filtering and improving the traces UI.

Filter for finding specific API tokens easily

You can now find specific API tokens more easily. The new token filtering feature lets you filter tokens by name using a search input that appears automatically when you have 10 or more API tokens. Simply type part of a token name to quickly narrow down your list and find the token you're looking for. This makes managing large numbers of tokens much more efficient, especially for organizations with many API tokens for different services or environments.

Improved traces UI

The traces interface has received a design update, making it easier to navigate and understand your trace data. The updated UI provides better visual hierarchy, clearer span relationships, and improved navigation between related traces and logs.

Analyzing generative AI (GenAI) conversation data in your logs just got easier. Previously, extracting insights from AI conversation logs required complex queries to parse message structures, calculate token costs, and filter conversations by role or content.

We’ve added a comprehensive set of GenAI functions to APL that simplify working with conversation data from large language models and AI systems. These functions help you extract specific information like user prompts, assistant responses, and system prompts, calculate token costs and usage metrics, analyze conversation structure and flow, and detect truncation or tool calls in responses.

For more information, see the blog or the documentation.

More of our favorite changes

• Added snow mode toggle to the theme selector for a festive winter interface

• Added tooltip to Stream tab for metrics datasets to provide helpful context

We’ve added support for offline evaluations (evals) in the AI engineering workflow and improved alerting for data availability this week. These updates allow you to evaluate AI capabilities and stay informed when your data starts flowing again.

Offline evals for AI engineering

Evals are systematic tests that measure how well your AI features perform by automatically running your AI code against test collections and evaluating the results using custom scorers.

Instead of manually testing AI outputs or relying on anecdotal checks, evals provide a data-driven approach to:

• Catch regressions before they reach production

• Compare different models, prompts, or approaches

• Track quality improvements over time

• Ensure capabilities meet your quality benchmarks

The evaluation framework uses a declarative Eval function that lets you define test suites directly in your codebase with ground truth data, scoring functions, and configurable flags for experimentation. The Axiom AI SDK captures detailed OpenTelemetry traces for each evaluation run, allowing you to analyze results in depth.

See the blog post or learn more about setting up and running evals in the documentation.

Alerts when data returns after no-data state

Monitors with Alert on no data enabled now send notifications when data returns after a no-data alert state. Previously, you only received alerts when data stopped flowing, but not when it resumed. Now you get notified both when data disappears and when it comes back, giving you complete visibility into your data availability.

More of our favorite changes

• Improved bar chart hover interactions and visual feedback

• Improved ability to save views even when there are no events in the selected time range

• Enhanced authentication error handling for better user experience

We’re excited to introduce a foundational capability that expands how you can use Axiom: a unified edge deployment architecture.

Unified edge deployment architecture

Axiom now uses a unified edge deployment architecture that gives you more control over where your event data is stored while maintaining a single, unified management experience. When you create an organization, you choose a primary edge deployment like US East 1 (AWS) or EU West 1 (AWS), and your event data is stored at rest in that infrastructure.

This unified model provides flexibility that wasn’t possible with separate regional instances. You manage everything through Axiom’s Console at app.axiom.co regardless of which edge deployment you select, eliminating the need to juggle multiple accounts or endpoints. As Axiom introduces additional edge deployments, you’ll be able to write event data to specific locations with ease while maintaining unified management and billing.

Currently, when you select a non-US edge deployment, your event data is ingested and stored in your selected edge deployment, and queries execute in that same edge deployment. Query results are routed through US infrastructure, but your event data remains stored in your chosen edge deployment. Axiom is working toward complete within-edge query processing, where the entire operation (from query execution to results) will happen entirely within your selected edge deployment.

This architecture is particularly valuable if you need to meet data sovereignty requirements or prefer to keep your data closer to your operations. For more information, see Edge deployments.

Smarter dashboard refreshing

Charts now only refresh when their configured interval has elapsed, not every time you switch back to a dashboard tab. This prevents unnecessary network calls and makes dashboards more responsive, especially when you have many charts configured with different refresh intervals.

Enhanced Spotlight interactions

Spotlight insight charts are now more interactive and reliable. You can click directly on chart elements to access context menus, making it faster to explore your data. We’ve also fixed chart overlap issues and improved how nested fields are handled, ensuring Spotlight queries run more efficiently and display correctly.

These improvements make Spotlight feel more responsive and reduce visual glitches when working with complex nested data structures.

More of our favorite changes

• Enhanced toast notifications to remain interactive when dialogs are open

• Improved trace panel performance for faster loading

• Improved dataset sorting by ownership and sharing organization

This week was a big one for Axiom! We introduced support for OpenTelemetry metrics. In other news, we improved parsing of GenAI attributes in OpenTelemetry traces and improved the user interface for several other features.

Metrics

Axiom introduces support for OpenTelemetry metrics through a powerful visual query builder. The new interface provides an intuitive way to filter, transform, and aggregate metrics.

What's new

The metrics query builder in the Console lets you:

• Select the data source in a familiar visual interface: Choose your dataset and metric in the Builder, similarly to how you would query logs and traces.

• Filter by tags: Use the Where section to filter series based on tag values with familiar operators.

• Transform data: Apply transformations like rate calculations, interpolation, and value filling to prepare your data for analysis.

• Aggregate over time: Use the align transformation to aggregate metrics into time windows.

• Group by dimensions: Combine series by tags using the group transformation to analyze metrics across different dimensions.

Build your first query

To get started:

1. Ingest metrics data to Axiom using the OpenTelemetry Collector.

2. Go to the Query tab and click Builder.

3. Select your OTel metrics dataset and the metric you want to query.

4. Add filters in the Where section to focus on specific series.

5. Apply transformations to calculate rates, aggregate over time, or group by tags.

6. Click Run to see your results.

The builder supports all the core operations you need for metrics analysis, from simple filtering to complex aggregations. Whether you're tracking request rates, analyzing latency distributions, or monitoring system health, the visual interface makes it straightforward to extract insights from your metrics data.

Example query and results

For more information, see the blog and the documentation.

Better parsing of GenAI attributes

OpenTelemetry GenAI attributes are now handled more intelligently. Previously, attributes with JSON content were represented as strings. These attributes are now parsed and represented as array types. This allows for a better structure and queryable format.

For example, gen_ai.input.messages and gen_ai.output.messages are now parsed as arrays:

{
    "gen_ai.input.messages": [{"role": "user", "content": "What is the weather?"}],
    "gen_ai.output.messages": [{"role": "assistant", "content": "I need more information about your location."}]
}

This makes it easier to query and analyze message history directly in your traces.

If you're monitoring LLM applications or AI workloads, you'll see richer detail in your traces without any changes to your instrumentation. For more information on observability for AI apps, see the documentation.

RBAC permission enforcement

RBAC permission enforcement has been strengthened for some endpoints. Custom roles now require explicit read permissions to access billing info, datasets fields schemas, and field information. If you have custom roles that previously accessed these endpoints without read permissions, update the role configuration to grant read access. Axiom's built-in roles already include appropriate permissions and aren't affected by this change.

More of our favorite changes

• Improved side panel behavior in dataset settings.

We’ve been busy making Axiom more flexible and intuitive. Last week’s updates focused on removing barriers to data exploration, improving view access controls, and more reliable API interactions.

Enhanced view access controls

Views now work correctly for users who have been granted access to specific views but don’t have broader dataset permissions. Previously, you might encounter issues when trying to use views without underlying dataset access. The system now properly recognizes view-specific permissions and ensures that trace links and field metadata work correctly within view results.

This improvement makes view-based access control more practical for teams that need to share specific data slices without exposing entire datasets.

More reliable PagerDuty incident resolution

Several issues with PagerDuty integration have been fixed that were preventing incidents from resolving correctly. When monitors detected that issues were cleared, PagerDuty incidents weren’t always being updated or resolved as expected.

These fixes ensure that the full lifecycle of your incidents—from creation to resolution—flows reliably between Axiom monitors and PagerDuty. Your on-call workflows should now work more smoothly, with incidents opening and closing as they should.

AI-assisted queries without specifying a dataset

You can now generate queries using AI without specifying a dataset upfront. When you start a query, Axiom’s AI assistant intelligently determines the appropriate dataset based on your natural language question. If your question doesn’t map to a specific dataset, the assistant generates generic APL patterns that work across your data.

This makes exploratory analysis faster and more intuitive, especially when you’re not sure which dataset contains the information you need or when you’re writing queries that could apply to multiple datasets.

Updated subprocessors

We’ve updated our list of subprocessors to include Vercel and PlanetScale as infrastructure providers, and we’ve removed Koala. Vercel supports Console deployment infrastructure, and PlanetScale handles app configuration—your event data continues to be stored and processed exclusively in Axiom’s core data platform. These additions support our platform’s reliability and scalability.

Review our complete and up-to-date list of subprocessors.

More of our favorite changes

• Improved icon rendering performance to prevent layout shifts

• Enhanced query alignment resolution before submission

• Better default aggregation handling with required group by operations

Audit logs now give you a clearer picture of what’s happening across your organization.

Richer context in audit logs

Audit logs now capture significantly more context about how your team interacts with Axiom. When you review audit logs, you’ll see privacy-safe representations of the queries being run, making it easier to understand what’s happening across your organization without exposing sensitive data in query strings.

Audit logs now also track the source of each query—including which monitor triggered it—so you can trace query activity back to its origin. This is particularly useful when debugging performance issues or understanding which monitors are generating the most query load. Dashboard tracking is coming soon to provide even more visibility.

Query cost tracking and storage usage are now included in audit logs, giving you better visibility into resource consumption patterns. This helps you identify expensive queries, optimize performance, and understand how different teams use their query and storage budgets.

These enhancements make audit logs more actionable for governance, debugging, and cost optimization workflows.

Monitor high-cost queries

With query cost tracking now available in audit logs, you can set up monitors to alert you when expensive queries run. Here’s an APL example that identifies queries exceeding your cost threshold of 1000 query units:

['axiom-audit']
| where action == 'runAPLQueryCost'
| where ['properties.query_cost_gbms'] > 1000

Use this query as a monitor to get notified when expensive queries run. You can adjust the query_cost_gbms threshold based on your organization’s usage patterns and budget.

Check out the audit logs documentation for more details.

Additional improvements

• Fixed OpenTelemetry span handling.

• Improved dataset handling during subscription updates.

• Fixed spend limit notification logic to ensure alerts are sent correctly.

We've been hard at work improving the core query experience and fixing some key usability issues. Last week's updates focused on making your data exploration faster, more reliable, and more intuitive.

Better chart validation feedback

Chart input validation now provides clearer visual feedback. When a chart validation rule fails, you'll see a red cross instead of a grey checkmark. This makes it easier to understand what needs to be fixed when building dashboard elements.

The improved visual cues help you quickly identify and resolve chart configuration issues, making dashboard creation more intuitive and efficient.

Filter for datasets in dashboards

We've added documentation for filtering datasets in dashboards. This feature allows you to select specific datasets, and the dashboard only shows data from the dataset you choose.

The example APL query below defines a chart that only displays data from the specified dataset, making it easier to create focused, purpose-built dashboards for different use cases.

declare query_parameters (dataset_filter:string = "");
table(dataset_filter)
| summarize count() by bin_auto(_time)

Check out the updated documentation to learn more about this powerful dashboard organization feature.

Query metrics inside Axiom

Our metrics querying capabilities continue to progress well behind the scenes. We've been working hard to integrate the metrics query experience directly into the Axiom Console, bringing you a unified interface for both logs and metrics analysis.

With MetricsDB, you'll be able to:

• Query metrics alongside your log data in a unified interface

• Create monitors and alerts based on your metrics data

• Create dashboards that combine logs and metrics seamlessly

The development is advancing smoothly, and we're on track to make this feature available for public preview this calendar month. If you're interested in being one of the first organizations to get onboarded with metrics querying in Axiom, please contact us to express your interest in being part of the private preview.

More of our favorite changes

• Fixed dataset library loading issues

• Enhanced Vercel integration with request duration metrics

• Improved payment method API responses for better error handling

• Fixed dataset list performance issues that could cause interface lockups

• Better handling of missing datasets with graceful error recovery

We were busy refining the core query experience last week, making it faster and more intuitive to explore your data. These updates focus on streamlining workflows that you use every day, from field selection to trace correlation.

Enhanced query field interactions

Working with fields in the query builder is now more intuitive. Previously, when you viewed the query results and clicked a field name in the sidebar, Axiom opened unique values. You can now select fields by clicking field names, and clicking the number on the right of a field name displays the unique values. This makes building queries faster and reduces unnecessary clicks when you’re exploring your data.

Smarter trace correlation across datasets

Trace linking just got smarter. Previously, you could only correlate logs and traces when the trace ID was stored in the trace_id field. Now, Axiom automatically detects trace IDs in any field containing trace in its name, whether that’s attributes.trace_id, custom_trace_id, or any other variation.

This enhancement makes it much easier to correlate between your logging and tracing datasets, especially if you’re using custom field naming conventions or migrating from other observability platforms.

Support for new versions of OpenTelemetry semantic conventions

We have added support for versions 1.36 and 1.37 of OpenTelemetry semantic conventions. These versions introduce updated attribute names for AI operations. Your existing traces continue to work seamlessly, while new traces benefit from the latest standards for tracking AI prompt inputs and completion outputs.

This ensures you’re getting the most accurate and standardized view of your generative AI workloads.

Adding support for new versions of OpenTelemetry semantic conventions means that the shape of your data can change. For more information, see Semantic conventions.

Enhanced data ingestion safeguards

We’ve strengthened data ingestion with better handling of edge cases and invalid data. Axiom now automatically sanitizes problematic data during ingestion to ensure your datasets remain clean and queryable.

When you ingest data that exceeds our limits, Axiom now handles it gracefully by replacing oversized strings with clear indicators, converting invalid float values like NaN and infinity to null, and preventing deeply nested structures from breaking your queries. We’ve also improved how reserved field names are handled — if you accidentally use internal field names like _sysTime, Axiom automatically renames them with a _user_ prefix to avoid conflicts.

These improvements mean more reliable data ingestion and fewer surprises when exploring your datasets, especially when working with diverse data sources or migrating from other platforms. For more information, see Limits on ingested data.

More of our favorite changes

• Enhanced help text for data trimming operations

• Better date parsing that now correctly handles formats like 25/09/2025, 19:15

• Improved chart options menu with better organization and visual hierarchy

• Fixed query field pagination to prevent infinite loading loops

• Better modal context handling for chart editing interfaces

• Fixed chart options editing interface that was previously inaccessible in some scenarios

• Resolved issue where query builder menus could be hidden behind other interface elements

• Fixed alignment issues in section bar actions across the dashboard

• Improved error handling for date parsing edge cases

Take control of your usage costs with two new features: compute credits and spending limit. Together, they give you more flexibility and predictability in how you manage spend on Axiom.

Compute credits let you pre-purchase usage at a discount, so you can save while covering core costs like data loading and query compute. The more you buy upfront, the more you save—making it easier to budget for growth while still enjoying the speed and scale of Axiom.

Spending limit adds an extra layer of control by letting you set a monthly cap on usage-based costs. Once your organization reaches the limit, Axiom automatically pauses usage that would incur further charges, such as running queries or monitors. This helps you stay within budget, though it may cause service interruptions until the next cycle begins.

With these features, you get the best of both worlds: flexibility to save with credits and confidence in knowing your spend won’t exceed what you planned.

Ready to take control of your costs? Learn more in the docs or head to Settings > Billing to try it out today.

Spotlight now generates AI-powered summaries to complement its visual comparisons. Instead of manually interpreting charts and distributions, you can now use Spotlight to get clear, concise explanations of the key differences between selected and baseline data. This makes it easier to spot root causes, understand anomalies, and communicate findings to your team, without needing to pore over every visualization.

Why it matters

Spotlight already highlights the most significant differences between selected events and baseline data. But interpreting charts, distributions, and outliers still required careful manual review. With AI summaries, you get clear, human-readable explanations of what the data is telling you—saving time and reducing cognitive load when troubleshooting issues.

What’s new

• Automatic insights: AI-generated summaries explain key differences across fields without requiring you to interpret every visualization.

• Faster root cause analysis: Quickly see why traces are slower, errors spike, or performance degrades.

• Clearer communication: Summaries make it easy to share findings with teammates, bridging the gap between technical data and actionable insights.

Whether you’re tracking down anomalies, validating monitor health, or exploring unknown datasets, AI summaries make Spotlight a sharper tool for investigation.

Get started

Run Spotlight on any dataset and see the AI-generated summaries alongside your visualizations. Learn more in the blog and the documentation, and experience Spotlight directly in the Playground.

We’ve expanded Axiom MCP Server to work seamlessly as a remote connection, making it easier than ever to bring your data into AI agents like Claude and Cursor. Additionally, Axiom MCP Server now supports a set of powerful prompts designed to accelerate common observability workflows and take you from raw events to insights faster.

Remote MCP Server access

Until now, using MCP with Axiom meant running a local server. That worked well for developers, but it added setup steps and maintenance overhead. The new remote MCP option lets you connect in seconds, so you can start asking your AI assistant meaningful questions about your data right away.

How remote MCP Server works:

• Remote server access at https://mcp.axiom.co/mcp with zero local dependencies.

• Seamless authentication via your browser, with the option to revoke access anytime.

• Works with any MCP-compatible agent, so you can query and explore your Axiom data from your preferred AI assistant.

Whether you’re troubleshooting an incident, checking monitor history, or exploring new datasets, connecting remotely lets you focus on the questions, not the setup.

Supported MCP prompts

In addition to core MCP tools like schema exploration, saved query retrieval, and APL execution, the server now supports the following domain-specific prompts:

• Correlate events across datasets

• Investigate data quality issues

• Detect anomalies in events

• Establish performance baselines

• Explore unknown datasets

• Analyze monitor health

Together, these prompts help you move from raw data to actionable insights faster, whether you’re debugging production issues, analyzing anomalies, or validating the health of your monitors.

Get started

Set up a remote connection in your AI agent and authenticate once in your browser to start exploring. For details, see the Axiom MCP Server documentation.

Back in December 2024, the Axiom MCP server started as a simple way to ask natural language questions and get powerful answers from your event data. Now, it’s becoming a lot more than that.

We’ve added four new tools to expand what’s possible when connecting Axiom to your favorite LLM clients:

• getDatasetSchema helps you explore unfamiliar datasets by revealing their structure up front.

• getSavedQueries taps into your team’s existing knowledge, giving LLMs access to your most-used patterns.

• getMonitors lets models understand what’s critical to your operations by pulling in your current monitors.

• getMonitorsHistory provides visibility into how those monitors have behaved over time, making trends and anomalies easier to spot.

These additions turn the Axiom MCP server from a basic querying interface into a well-rounded observability companion. Whether you’re debugging issues, summarizing incidents, or guiding an AI assistant through a dataset, you now have the tools to bring in the right context, right when it’s needed.

Start building with the Axiom MCP server today. Check out the open-source implementation on GitHub.

Update default version of OpenTelemetry semantic conventions

We have updated the default version of OpenTelemetry semantic conventions from 1.32 to 1.33. This means that the shape of your data can change when you don’t specify the version of the OTel semantic conventions in the data you send to Axiom. For more information, see Semantic conventions.

Axiom introduces Spotlight, a powerful new feature that transforms how you investigate issues by automatically surfacing the most relevant differences between selected events and baseline data.

Instead of manually crafting queries to understand anomalies, Spotlight lets you select a region on any line chart or heatmap and immediately see what makes those events unique. Spotlight analyzes every field in your data and intelligently presents the most significant differences through adaptive visualizations.

Key use cases

• Root cause analysis: Spotlight the slowest traces in your service to instantly see if they’re concentrated in a specific endpoint, region, or user segment—no complex queries required.

• Error investigation: When errors spike, highlight that time period to automatically discover the underlying cause, whether it’s a new deployment, specific user actions, or infrastructure changes.

• Growth insights: Spotlight an uptick in new sign-ups to quickly understand what’s different about your new users and optimize your acquisition strategy.

How it works

1. Select any region on a line chart or heatmap where you want to investigate anomalous behavior

2. Run Spotlight to automatically compare the selected events against your baseline data

3. Discover insights as Spotlight ranks and visualizes the most significant differences across all fields

Learn more about Spotlight in our documentation.

Axiom introduces views, a powerful new feature that lets you filter and reshape your data for downstream usage.

Views allow you to use APL (Axiom Processing Language) to create virtual datasets from data you‘ve already ingested. You can create views that:

• Filter events from source datasets based on specific conditions

• Remove or redact sensitive columns to manage access to PII

• Enrich data with additional computed columns

• Combine multiple datasets through unions or joins

Views are perfect if your organization needs to provide different teams access to specific subsets of data without duplicating ingest or creating complex instrumentation. For example, you can create a view that filters out sensitive customer information for your support team while maintaining the complete dataset for your security team.

You can query views, use them in dashboards and monitors, and share them externally just like standard datasets. You can also manage views using Role-Based Access Control (RBAC) to maintain fine-grained control over who has access.

To get started with views, see our documentation.

The ingest endpoint just got smarter. We’ve expanded support for the Content-Type: application/json header, so it now accepts both JSON arrays and newline-delimited JSON (NDJSON).

This improvement solves a common pain point for teams working with third-party tools or SDKs that don’t allow customizing the Content-Type header. Previously, sending NDJSON required setting application/x-ndjson, which wasn’t always feasible. Now, Axiom accepts NDJSON even when the header is set to application/json, making integrations simpler and more forgiving.

Whether you’re piping logs from a custom client or wiring up a webhook, your data gets where it needs to go, no header gymnastics required.

Try it out today or read more in the documentation.

Skip the blank canvas. Describe your ideal dashboard, and let AI do the rest.

If building dashboards from scratch has ever felt like a chore, this feature is for you. Instead of manually selecting fields, charts, and filters, you can now tell Axiom in plain language what you want to see, and our AI will generate a complete dashboard in seconds.

Whether you’re monitoring latency trends, tracking user behavior, or auditing error spikes, AI-powered generation gives you a head start tailored to your goals. The more detail you provide, the more precise and relevant the results. You’ll still have full control to tweak and expand the generated dashboard, but the heavy lifting is handled for you.

Behind the scenes, our AI analyzes the dataset you choose and interprets your description to assemble a dashboard with the most appropriate visualizations. It’s a simple yet powerful way to accelerate observability, reduce time-to-insight, and free up your brain for actual analysis.

And it’s not just dashboards. We’re also making saved queries smarter. When you save a query, Axiom now suggests a descriptive name automatically, powered by AI. No more generic names or forgotten context.

Read the docs to learn how to create your first AI-generated dashboard and AI-named saved query today.

As of June 12th, 2025, Axiom will support OpenTelemetry (OTel) semantic conventions from version 1.21 to version 1.32. The default version will become version 1.32.

As a result, attributes in your OTel data that previously didn’t match supported conventions will be recognized and properly interpreted in Axiom.

This can change the shape of your data (where you can find different attributes in your data), but it doesn’t mean the loss of data in any way.

The changes will become effective on June 12th, 2025.

For more information, see Semantic conventions and the full list of versions of OTel semantic conventions that Axiom supports.

Support for new versions can affect the shape of your data

If you use an unsupported version that becomes supported as a result of this change, the shape of your data can change:

• Before the update, attributes that Axiom couldn’t match to the previously supported semantic conventions were nested under the attributes.custom field.

• After the update, Axiom matches these attributes to the newly supported semantic conventions. The newly recognized attributes are nested under the attributes or resource fields, similarly to all other attributes that follow semantic conventions.

Action required as a result of support for new versions

If previously unrecognized attributes become recognized in your data after this change, you need to take action on June 12th, 2025.

Update all saved queries, dashboards, or monitors that reference attributes previously stored in attributes.custom to reflect their new location under attributes or resource.

For more information on the actions you need to take, see the documentation.

Changing default version can affect the shape of your data

If you don’t specify the version of the OTel semantic conventions that your data follows when you send OTel data to Axiom, Axiom interprets the data using the default version:

• Before June 12th, 2025, the default version is version 1.25.

• After June 12th, 2025, the default version will be 1.32.

This means that the attributes that became supported or deprecated between these versions can change in Axiom:

• Attributes that became supported between versions 1.25 and 1.32 used to be nested under the attributes.custom field. After June 12th, 2025, these attributes will be nested under the attributes or resource fields.

• Attributes that became deprecated between versions 1.25 and 1.32 used to be nested under the attributes or resource fields. After June 12th, 2025, these attributes will be nested under the attributes.custom field.

Action required as a result of changing default version

If previously unrecognized attributes become recognized in your data after this change or vice versa, you need to take action on June 12th, 2025.

Include the version of the OTel semantic conventions that your data follows when you send OTel data to Axiom. This ensures that your data is properly interpreted in Axiom and it won’t be affected when Axiom changes the default version.

For more information on the actions you need to take, see the documentation.

Changes to events and links

Previously, semantic and non-semantic attributes were separated inside span events and links. This meant unnecessary additional fields in your datasets. Now semantic and non-semantic attributes aren’t separated inside span events and links.

Update plan

Axiom plans to update the supported and default versions of OTel semantic conventions regularly. To prepare for these changes:

• When you send OTel data to Axiom, include the version of the OTel semantic conventions that your data follows. This ensures that your data is properly shaped in Axiom and it won’t be affected when Axiom changes the default version.

• If you send data to Axiom using a currently unsupported version of OTel semantic conventions, be aware that the shape of your data can change when Axiom adds support for new versions.

We’ve redesigned the Dataset tab to make exploring your data faster, cleaner, and more intuitive—and added powerful new controls for configuring map fields.

In observability, clarity matters. Our updated UI helps you navigate fields with confidence, spotlight insights with quick charts, and zero in on what you need, whether that’s a saved query or a deeply nested virtual field. Every pixel of the Dataset tab now works harder to give you better visibility into your data.

The upgrade doesn’t stop at the surface. You can now fully manage map fields (those handy, JSON-style key-value collections) directly from the UI. View removed or unused map keys, inspect nested data with ease, and maintain schema hygiene without diving into raw payloads.

We also smoothed out interactions across the board:

• Cleaner field lists

• Faster access to saved queries and history

• Streamlined editing of field descriptions and units

The result? Less time spelunking, more time analyzing.

Check out the details of the new Dataset tab and the map field configuration feature in the documentation.

Turn natural-language prompts into queries in one keystroke.

Axiom introduces a natural language to query generator that turns your plain English into powerful insights. Now you can simply describe what you want to see in your data and our AI will do the heavy lifting of creating the technical query for you.

Struggling to remember APL syntax? Just press <kbd>Cmd/Ctrl</kbd> <kbd>K</kbd> in the query editor, type something like “Show me the most common status responses in HTTP logs” and watch as the AI transforms your request into a valid APL query. You maintain full control with options to accept, modify, or reject the generated query before running it.

This feature bridges the gap between what you want to know and how to ask for it technically, making data exploration more intuitive for both APL experts and newcomers. The query generator remembers your previous prompts too, so you can quickly iterate on past queries by cycling through your history with arrow keys.

Ready to simplify your data exploration? Start conversing with your data today by pressing <kbd>Cmd/Ctrl</kbd> <kbd>K</kbd> in the APL query editor and see how it transforms your workflow, or check out our documentation to learn more.

Turn Axiom AI on or off

Features powered by Axiom AI are turned on by default for most customers. You can turn them on or off anytime, for example, for regulatory and compliance reasons.

For more information, see the documentation.

The progressive query status bar gives you a real-time window into your query’s journey. While you’re used to watching that spinning wheel in batched query mode, progressive queries now give you a dynamic status bar that keeps you informed every step of the way.

The new status bar continuously updates with three crucial metrics:

• Rows examined: See exactly how much data your query has processed.

• Rows matched: Track how many records meet your search criteria.

• Rows returned: Monitor your result set as it builds.

This enhancement transforms the query experience from a black box into a transparent process. For complex queries or large datasets, you’ll no longer wonder “Is anything happening?” Instead, you’ll have clear visibility into your query’s progress, helping you make better decisions about query optimization and runtime expectations.

Ready to experience this enhanced visibility? Try progressive query mode today in the Axiom web app or the Playground and watch your queries unfold in real-time.

Axiom introduces version 2 (V2) API endpoints that let you manage new Axiom resources programmatically. For more information, see the list of API endpoints.

New endpoints

The following endpoints are new ways to programmatically create, read, update, and delete Axiom resources. Previously, you could only manage these resources from the UI:

• Groups

• Monitors

• Notifiers

• Organizations

• Roles

• Starred queries

• Users

• Virtual fields

Axiom added new endpoints for the following tasks:

• Retrieve information about fields and update them

• Vacuum datasets

To work with the new endpoints, use advanced API tokens with the correct permissions. For example, to create users programmatically, first create an advanced API token with these privileges, and use this token to authenticate your request to the users endpoint.

New version of existing endpoints

Axiom introduces V2 of the following existing endpoints:

• List all datasets

• Create dataset

• Retrieve dataset

• Update dataset

• Delete dataset

• Retrieve current user

For these tasks, Axiom recommends you use the new V2 endpoints. The functionality and the interface are unchanged, and the properties remain the same as before. V1 endpoints continue to be supported and you can use them as before. The V2 endpoints offer backend improvements over their V1 counterparts. This enables more efficient and maintainable service from Axiom in the future.

Bring your data with you, wherever it lives.

The externaldata operator lets you query data from external storage systems like Azure Blob Storage, AWS S3, or public HTTP endpoints—no imports or pipeline setup required. Whether you’re wrangling lookups from a CSV in cloud storage or tapping into raw JSON logs hosted elsewhere, externaldata lets you treat external files like native Axiom datasets.

This feature is perfect for teams that need fast, one-off access to external reference data or archived logs without moving them into Axiom. Enrich your queries with real-time data joins, lookups, or supplemental context without duplicating storage or breaking flow.

It’s especially handy for:

• Augmenting logs with external user or service metadata

• Merging OpenTelemetry traces with a hosted lookup table

• Running ad hoc analysis on remote JSON, CSV, or TXT files

All it takes is a schema definition and a public URL. Axiom fetches the data and makes it instantly available in your query.

This operator is currently in public preview, and we’re actively working on expanding format support and size limits. Try it out with a simple join or a one-off query to see how much easier data enrichment can be, especially when your data isn’t all in one place.

Check out the externaldata documentation for use cases and examples.

Searching in thousands or even tens of thousands of events at once is no small feat. While a browser’s native search only scans what’s on your screen (due to “virtualization” that prevents performance bottlenecks), Axiom now includes a dedicated search functionality that checks for every result your query returns, even if it’s not yet rendered in the DOM.

Why it matters
Large queries can produce thousands of events, far exceeding what you’d want browsers to render all at once. To keep things running smoothly, applications like Axiom render event rows as needed. However, this makes default browser search fall short, only highlighting the visible rows. We’ve solved that gap by letting you search all query results end-to-end. If your query pulls 10 events, you’ll search across those 10; if it returns 50,000, you’ll search across all 50,000.

Key benefits

• Complete coverage: Spot every instance of the keyword within your query results. No missed matches.

• Effortless navigation: Jump quickly to each match without manual scrolling through massive logs.

• Performance-friendly: Axiom honors any limits you set, so you only search the data you actually need.

How it works
Built into our query results view, the search automatically looks across all returned events. This lets you find hidden insights without switching back and forth or loading more data in your browser tab.

Ready to try it out? Head to our documentation for more details, or jump into the Playground and press <kbd>Cmd/Ctrl</kbd> <kbd>F</kbd> in the query results view to see how this streamlined search can save you time in debugging and analysis!

Introducing our new lookup operator—the secret sauce to turning your plain logs into rich, insightful data. Gone are the days of tediously piecing together information; now, a simple join brings your data to life. With lookup, you can easily enrich your primary dataset by linking it to a lookup table, giving you the context you need—whether you’re mapping user IDs to profiles or adding extra layers to your security logs. Enjoy a streamlined, intuitive approach to data enrichment that makes your insights not just smarter, but a lot more engaging.

The lookup operator supports both inner and leftouter flavors, offering flexibility to include all records or only matching entries. Its clear syntax and straightforward parameters make it a breeze to integrate into your workflows, ensuring you spend less time on data wrangling and more time on insight-driven actions.

Ready to simplify your data enrichment process? Explore the new lookup operator in our documentation and experience the benefits firsthand.

We’re happy to announce that you can now use the redact APL operator to replace sensitive or unwanted data in string fields with regular expressions.

You can use the redact operator to sanitize log data, obfuscate personal information, or anonymize text for auditing or analysis. The operator allows you to define one or multiple regular expressions to identify and replace matching patterns. You can customize the replacement token, generate hashes of redacted values, or retain structural elements while obfuscating specific segments of data.

The redact operator is useful when you need to ensure data privacy or compliance with regulations such as GDPR or HIPAA. For example, you can redact email addresses, IP addresses, and other personally identifiable information from logs and datasets.

For more information, see redact operator in the documentation.

You can now share Axiom datasets with clients and collaborators.

Dataset sharing allows you to grant query access to your datasets to other Axiom organizations. In addition to directly querying the dataset, the receiving organization can also create other Axiom resources that rely on query access, such as dashboards and monitors.

If you're managing event data for clients, dataset sharing is a great way to empower your client users to self-serve their own insights, while you retain full control over ingest and dataset management.

Dataset sharing is available for all organizations on our Team or Enterprise plans. Check out our documentation to learn how to get started with dataset sharing today.

We’re happy to announce that you can now get an overview of a monitor’s current status, history, and recent viewers.

The monitor status page allows you to:

• View recent activity and history of runs

• View information about monitor configuration

• Check recent viewers of monitor status

For more information, see the documentation on monitor status.

Additionally, Axiom has improved how data is visualized in the Query tab. Previously, it could often be that the summarize statement only returned a table without a chart. You can now use summarize and expect Axiom to better infer the visualization from your query.

We’re happy to announce that you can now resize the span details view. Previously, the size of the span details view was fixed. This meant that for large traces, you could not easily look at the waterfall view of traces and the span details at the same time. You can now resize the view to your needs and easily cross-reference information between the waterfall view and the span details view.

For more information, see the documentation.

We’re excited to announce that we have added seven new IP functions to Axiom Processing Language (APL).

• has_any_ipv4 checks whether a field contains any IPv4 addresses from a specified set of IPv4 addresses.

• has_any_ipv4_prefix checks if an IPv4 address starts with any prefix in a list of specified prefixes.

• has_ipv4 checks if an IPv4 address appears in a specified text.

• has_ipv4_prefix checks if an IPv4 address starts with a specified prefix.

• ipv4_compare compares two IPv4 addresses.

• ipv4_is_in_any_range checks whether an IPv4 address belongs to any range of IPv4 subnets.

• ipv4_is_match checks whether an IPv4 address matches an IPv4 pattern.

We have also added the percentileif aggregation function. It calculates the requested percentiles of a field for the rows where a condition evaluates to true.

For more information, see the documentation.

We’re excited to announce that you can now create continuous flows.

Flows enable you to filter, shape, and route event data to a destination. Previously, you could only create one-time flows, which are one-off operations that process past data for a specific time range and route the output to a destination. You can now create continuous flows, which are continuously running operations that process your incoming data and route the outputs to a destination in real-time.

Axiom Flow is currently in preview. To try it out, sign up for a free preview.

For more information, see the documentation.

We’re happy to announce that you can now set custom comparison time periods for individual dashboard elements.

Previously, each element on a dashboard compared data against the same time period or none. You determined this comparison period at the dashboard level.

You can now set a custom comparison time period for individual dashboard elements that is different from the dashboard’s. For example, the dashboard compares against data from yesterday but individual dashboard elements display data for different comparison periods.

For more information, see the documentation.

We’re excited to announce that you can now set a custom time range for individual dashboard elements.

Previously, each element on a dashboard displayed data for the same time range. You determined this time range at the dashboard level.

You can now set a time range for each element that is different from the dashboard’s time range. For example, the dashboard displays data about the last 30 minutes but individual dashboard elements display data for different time ranges. This can be useful for visualizing the same chart or statistic for different time periods, among others.

For more information, see the documentation.

We’re excited to announce that you can now specify a custom data retention period for each dataset.

The data retention period determines how long Axiom stores your data. By default, the data retention period is defined by your pricing plan and is the same for all datasets. You can now configure custom retention periods for individual datasets that are shorter than your pricing plan’s default retention period. As a result, Axiom automatically trims data after the specified time period instead of the default one defined by your pricing plan. For example, this can be useful if your dataset contains sensitive event data that you don’t want to retain for a long time.

For more information, see the documentation.

We’re happy to announce the introduction of the Query tab.

The Query tab provides you with a unified query builder experience. This change introduces a more logical structure to tabs and implements a clearer separation between the Datasets tab and the Explore tab. Previously, you could run queries in both the Datasets and the Explore tabs. The Query tab now replaces the Explore tab and the query capabilities of the Datasets tab. In this arrangement, the Datasets provides you with information about each field within your datasets, whereas the Query tab allows you to run queries and get deeper insights into your data.

We’re happy to announce the introduction of heatmap dashboard elements.

Heatmaps represent the distribution of numerical data by grouping values into ranges or buckets. Each bucket reflects a frequency count of data points that fall within its range. Instead of showing individual events or measurements, heatmaps give a clear view of the overall distribution patterns. This allows you to identify performance bottlenecks, outliers, or shifts in behavior. For instance, you can use heatmaps to track response times, latency, or error rates.

For more information, see Heatmap dashboard elements in the documentation.

We’re happy to announce that you can now use the _time field with the Vector collector version v0.42.0 or newer.

Before Vector version v0.42.0, the Axiom sink was based on an Elasticsearch endpoint. This constrained Axiom to the Elasticsearch wire semantics. When you sent data to Axiom, you had to specify the timestamp in the @timestamp field.

Starting with Vector version v0.42.0, the Axiom sink uses the native Axiom ingest endpoint. This means that you can specify the timestamp in the _time field as usual.

For more information, see the documentation.

We’re happy to announce that you can now install the Axiom CloudWatch Forwarder with Terraform modules.

The Axiom CloudWatch Forwarder allows you to send logs from Amazon CloudWatch to Axiom. Previously, you could only set it up with AWS CloudFormation stacks. You can now set up the Axiom CloudWatch Forwarder with Terraform modules.

For more information, see the documentation.

We’re excited to announce that you can now add three new elements to your dashboards.

Pie charts can illustrate the distribution of different types of event data. For example, a pie chart can show the breakdown of status codes in HTTP logs.

The note dashboard element adds a textbox to your dashboard that you can customise to your needs. For example, you can provide context in a note about the other dashboard elements.

The monitor list provides a visual overview of several monitors. It offers a quick glance into important developments about the monitors such as their status and history.

For more information, see the documentation on pie charts, notes, and monitor lists.

We’re excited to announce that you can now switch to the event details view by highlighting a specific time range on a chart.

In line charts and heat maps, you can drag the pointer over the chart to highlight a specific time range, and then choose one of the following:

• Zoom enlarges the section of the chart you highlighted. Previously, this was the default behavior.

• You now have the option to click Show events to display events in the selected time range in the event details view.

The time range of your query automatically updates to match what you selected.

We’re happy to announce that you can now easily integrate your Serverless apps with Axiom. Serverless is an open-source web framework for building apps on AWS Lambda. Sending event data from your Serverless apps to Axiom allows you to gain deep insights into your apps’ performance and behavior without complex setup or configuration. Axiom’s pre-built dashboard provides instant insights into your apps’ health and usage patterns.

For more information on setting up the integration, see the documentation.

For more information on the benefits of using the integration, see our blog post.

We’re excited to announce that the audit log is now available on all plans. The audit log allows you to track who did what and when within your Axiom organization. It gives you a complete view of user activity, data access, and changes made to key Axiom resources.

Previously, Axiom manually exported audit data upon request. The audit log is now queryable just like any other dataset. This means that you can build dashboards to track your favorite queries and create monitors to notify you of significant events.

For more information, see the documentation.

We’re excited to announce that Axiom now supports secure, centralized user authentication through the IdP-initiated flow for SAML-based SSO (identity-provider-initiated flow for Security Assertion Markup Language-based single sign-on). Previously, Axiom only supported the service-provider-initiated flow (SP-initiated flow). Axiom now supports both flows.

SAML-based SSO makes it easy to keep access grants up-to-date with support for the industry standard SCIM protocol. This feature is available for Enterprise customers upon request.

We’re happy to announce the introduction of anomaly monitors.

Anomaly monitors allow you to receive an alert when the results of your query deviate from what’s expected. In comparison to threshold monitors, which compare the results of your query against a fixed threshold, anomaly monitors use the recent behavior of the query to determine if the most recent results are anomalous.

For example, suppose you want to monitor response times for a range of API endpoints that you serve. Rather than identifying the correct threshold for each one, you can simply use an anomaly monitor to be alerted whenever there’s a sudden spike in response time. Anomaly monitors allow you to group the results of your query and track expected behavior for each group separately.

For more information, see Anomaly monitors in the documentation.

Creating charts in Axiom has become even easier. We’re excited to announce two improvements to the chart creation process.

Chart creation now includes input validation and in-app education. This assistive feature informs you about the requirements for the type of chart you’re creating, validates your input in real time, and educates you on how to build a query that matches those requirements. Input validation is available for both the visual and the APL query builder.

We have also streamlined the chart creation process to make it more intuitive. Now the first step is to choose the type of chart that you want to create, followed by a chart creation interface tailored to that chart type.

We’re happy to introduce the option to set the default method for null values.

When you run a query with a visualization, you can select how Axiom treats null values in the chart options. For more information, see Configure chart options.

Previously, you had to repeat this procedure for each chart you created. You can now select a default method to deal with null values that Axiom uses in every new chart you create.

For more information, see Profile settings.

We’re excited to announce major improvements to the results table and the event panel.

In the results table, you can switch between raw data and column modes. The raw data mode displays the raw event data and highlights the fields you select. The column mode displays each selected field in a different column and doesn’t show the raw event data. In column mode, you can resize the width of columns by dragging the borders.

In the event panel, you can navigate between events by clicking the Navigate up or Navigate down buttons. You can also change the height of the event panel to fit the viewport height or the height of the results table.

For more information, see the Query results in the documentation.

We’re happy to announce that Axiom complies with the core principles of the Health Insurance Portability and Accountability Act (HIPAA). HIPAA compliance means that Axiom can enter into Business Associate Agreements (BAAs) with healthcare providers, insurers, pharma and health research firms, and service providers who work with protected health information (PHI). Business Associate Agreements (BAAs) are available for Enterprise customers.

We’re thrilled to announce that you can now merge separate visualizations into a single chart. Previously, when you ran a query that produced several visualizations, Axiom displayed the charts separately. This is still the default behavior, but you can now choose to display the separate visualizations in a single chart. This enables you to get a better overview of trends in your data.

For example, the query below displays a different visualization for each percentile specified in the query:

['sample-http-logs']
| summarize percentiles_array(req_duration_ms, 50, 90, 95) by status, bin_auto(_time)

Run in Playground

To merge the separately displayed charts into a single chart, click the View options icon, and then select Merge charts. For more information, see Merge charts.

We’re thrilled to introduce that we’ve added multiple selection to times series charts. Previously, when you held the pointer over rows in the table below a time series chart, the chart displayed the data corresponding to that row. When you moved your pointer away, the chart showed all the data again.

Now you can select the checkboxes on the left of the rows. As a result, the chart only displays the data for the selected rows even if you move your pointer away. This means that your selection sticks until you clear the checkboxes.

Check out the new behavior of the time series charts in the Playground!

Axiom introduces a unified query builder experience in the Explore tab.

• A new toolbar has been added that provides you with all the tools to build your queries.

• The toolbar contains the buttons you could previously find dispersed in different parts of the UI: the time range selector, the button to run your query, and many more.

• Previously, you could only build queries using a visual tool in the Datasets tab or using APL in the Explore tab. Now you can build queries both ways in a single place, the Explore tab. All you need to do is select Builder in the toolbar for a visual query builder experience, and APL to structure queries using Axiom’s piped processing language.

These important updates are part of wider changes that we plan to release soon to improve your query experience.

A year ago, Axiom introduced the search operator to APL to let you explore your data in an unstructured way. While useful, it had limitations in handling complex data types and numbers.

Previously, you could only search for string values. Axiom now significantly expands the search operatorʻs capabilities:

• You can search for numbers. For example, search for a numeric customer ID directly.

• You can search inside complex data types such as maps and arrays.

The has and contains operators power the search operator and also receive these capabilities.

These improvements make it easier to dig deep into your datasets and find the information you need quickly, whether in casual exploration, deep investigation, or advanced monitor and dashboard setups.

Try out the enhanced search capabilities today and experience faster, more comprehensive data exploration. For more details on using the improved search operator, see the documentation.

Axiom users can now use custom webhooks to connect Axiom monitors with their favorite external services.

With the (old) webhook notifier type, it has always been possible to send a POST request to a URL of your choosing whenever a linked monitor triggered. However, the payload of this request had a fixed structure, which required transformation before forwarding to the desired destination.

With custom webhooks, it's now possible to modify the JSON payload, as well as add additional headers for including in the request. Using the Go template syntax, you can conditionally structure the payload depending on the circumstances of the trigger event.

This means that you can easily connect to and authenticate with external services even when they do not have have a dedicated notifier type in Axiom.

For more information, see our documentation.

We’re excited to introduce span links, a powerful feature that allows you to establish relationships between spans, even if they’re part of different traces. Span Links are useful for representing asynchronous operations or batch-processing scenarios where a subsequent operation may start at an unknown time or in a separate trace. By linking spans together, you can preserve the dependencies and connections between these operations.

• Capture asynchronous dependencies: Use span links to associate spans representing asynchronous operations, such as a span triggering a subsequent operation that may start much later or in a different trace altogether.

• Preserve batch-processing relationships: Establish links between spans to capture the relationships in batch-processing scenarios, where operations are processed in bulk and may not have direct connections within the same trace.

• Powerful querying with APL: Leverage the flexibility of Axiom’s Query Language (APL) to find traces with span links. Use the isnotempty(links) condition to quickly identify traces containing linked spans and dive into their details.

Check out the documentation to learn more and get started.

We’re excited to announce the launch of annotations, a new feature that enhances data visualization by allowing you to add contextual markers to charts. With this update, you can now annotate significant events like deployments, server outages, and incidents directly on your charts. This empowers you to easily correlate these events with trends in your data, streamlining the troubleshooting process for issues within your app or system.

Get started by creating annotations through our API and enrich your data analysis experience today. For more information, see Annotate charts.

Axiom introduces match monitors, a new type of monitor that filters for key events and sends them to you.

A monitor is a background task that periodically runs a query that you define and notifies you about the monitor output. Previously, you could only create threshold monitors. Threshold monitors aggregate event data over time, and when the results cross a threshold, Axiom sends you an alert.

Match monitors are a new type of monitor that lets you continuously filter your log data and send you matching events. For example, you set up a match monitor to filter for events where the duration of a request is longer than five seconds or where the level of severity of an error is critical. As a result, Axiom alerts you about every event that matches the filters you set.

For more information, see Monitor data.

We’re excited to introduce the ensure_field() function in APL, a convenient way to ensure the existence of a field and return its value or a typed nil if it doesn't exist. This function simplifies working with fields that may or may not be present in your data, making your queries more robust and reducing the need for complex null checks.

• Field existence check: Checks if the specified field exists in the data and returns its value if it does. If the field doesn't exist, it returns a typed nil based on the provided field type.

• Simplified field access: Access fields without worrying about null values or missing fields. The function handles these cases smoothly, making your queries cleaner and more readable.

• Future-proof queries: Prepare your queries for fields that are expected to exist in the future. For example, you can use ensure_field() to write logic around a field you know will be added soon, ensuring your queries are ready when the field becomes available.

• Migrating schemas: When migrating to a new schema that introduces new fields, ensure_field() can help you write queries that work with both the old and new schemas during the transition period.

Check out the documentation to learn more and get started.

We’re excited to announce the new parse operator in APL, a powerful tool for extracting structured data from string fields. This operator allows you to define parsing patterns using string constants, regular expressions, or a combination of both, and then assign the extracted values to new fields in the result set.

• Data extraction: Extract structured data from unstructured or semi-structured string fields, enabling you to transform raw data into a more usable format.

• Flexibility: Adapt to different data formats and requirements by supporting different parsing modes (simple, relaxed, regex) and providing various options to define parsing patterns.

• Performance: Optimize query performance by extracting only the necessary information from string fields, reducing the amount of data processed and enabling more efficient filtering and aggregation.

Check out the documentation to learn more and get started.

Axiom launches the Axiom Terraform Provider, an Axiom app that lets you provision and manage Axiom resources (datasets, notifiers, monitors, and users) with Terraform. This means that you can programmatically create resources, access existing ones, and perform further infrastructure automation tasks.

Install the Axiom Terraform Provider from the Terraform Registry. To see the provider in action, check out the example.

For a guide that explains how to install the provider and perform some common procedures such as creating new resources and accessing existing ones, see Manage Axiom resources with Terraform. For the full API reference, see the documentation in the Terraform Registry.

Axiom adds support for advanced API tokens.

Advanced API tokens let you perform a wide range of actions in Axiom. When you create an advanced API token, you select which actions you allow the advanced API token to perform. For example, you can create an advanced API token that can only query data from a particular dataset and another that has wider privileges such as creating datasets and changing existing monitors. This lets you assign only those privileges to API tokens that are necessary to perform the actions that you want.

After creating an API token, you cannot change the privileges assigned to that API token.

The API tokens you have previously created continue to function as before. They are now marked as classic tokens and you cannot regenerate them. If your classic API token expires, delete it and create a new one with the same privileges.

For more information, see Tokens.

Axiom adds support for field vacuuming and other improvements.

Field vacuuming wipes all fields and rebuilds the schema on the next event Axiom receives. This can be useful if the number of fields in a dataset exceeds the allowed limits defined by your pricing plan.

To learn more about vacuuming fields, see the documentation.

This release adds the following further improvements:

• Adds the possiblity to set a dashboard as your default starting page in the Axiom app.

• Adds support for searching for datasets in the Datasets, Stream, and Explore tabs.

Breaking changes to Splunk endpoint

This update changes how events received by the Splunk endpoints are stored in Axiom in the following ways:

• Renames the message field to _raw: This adjustment aligns with common data handling practices and improves the intuitiveness of data analysis.

• Includes the fields object in requests: Requests to the Splunk endpoint include the fields object to provide more comprehensive data capture.

Action required

If you use saved queries, dashboards or monitors for datasets associated with a Splunk endpoint, make the following changes on March 11th, 2024:

• Rename the message field to _raw in the affected queries.

• Ensure new fields do not collide with existing aliases or virtual fields.

We are excited to announce the union operator in APL, a powerful operator designed to enhance the merging of event data from multiple sources into a single dataset.

• Enhanced data combination: Easily merge rows from different datasets, creating a unified view of your event data.

• Simplified querying: Make your data querying easier by combining related or complementary datasets with a single operation.

• Improved data management: Handle complex datasets more effectively, allowing for more comprehensive data insights.

Check out the guide to learn more and get started.

Axiom lets you set up a notifier with Microsoft Teams and adds other improvements to notifiers.

The new notifier lets you integrate your monitors with Microsoft Teams. When a monitor triggers, you now have the option to send a notification to your organization’s Microsoft Teams instance.

This release adds the following further improvements to notifiers:

• Adds a Test button to the right of each notifier in the list of notifiers. Clicking this button triggers the notifier for a single test run. Use this feature to ensure a notifier works as intended.

• Adds the possibility to manage notifiers from the list of monitors. Previously, if you started creating a monitor but realised you hadn't created the notifier, you had to leave the monitor creation process. After this update, you can create notifiers without leaving this page.

To explore the new notifier features, go to your Axiom account.

Axiom adds a span duration histogram and other improvements to tracing.

The span duration histogram gives you a quick overview about the duration of individual spans within a trace. This histogram appears to the right of the waterfall view of traces. The span duration histogram can be useful in the following cases, among others:

• You look at a trace or an individual span and you only know its duration. There is no obvious error. You want to know if you are looking at something normal in terms of duration, or an outlier. The histogram helps you determine if you are looking at an outlier and might drill down further.

• You've found an outlier. You want to investigate and look at other outliers. The histogram shows you what the baseline is and what is not normal in terms of duration. You want to filter for the outliers and see what they have in common.

This release further improves tracing in the following ways:

• Adds support for deep linking to individual span inside a trace.

• Adds support for expanding multiple span events.

• Adds support to export traces in Axiom and Jaeger format.

• Improves the design of the trace waterfall view. With tighter data density, you can scan more spans efficiently.

• Improves the background contrast on span hover and click for readability.

• Changes search across spans so that it is now case insensitive.

• Fixes an issue where missing spans were duplicated if they had multiple children.

• Fixes an issue where child spans were displayed larger than their parent span due to rounding.

In addition, this release fixes an issue where the Grafana data source plugin couldn't query data from Axiom.

To explore the new tracing features such as the span duration histogram, go to the Axiom Playground and click a trace in the list.

Axiom lets you determine geo information like country, latitude, and longitude from an IP address.

If your event data contains a field with an IP address, you can now augment the event with geographical information with the geo_info_from_ip_address function in the Axiom Processing Language (APL). This function extracts geographical, geolocation, and network information. It supports both IPv4 and IPv6 addresses.

For more information, see the documentation on geo_info_from_ip_address.

This release adds a sidebar to the Datasets and Explore tabs where you can select the fields you want to display in the results table. Previously, you could only see the raw data in the results table. This prevented you from focusing exactly on the fields you were interested in. The new sidebar enables you to customize the results table and to see exactly the fields that are important to you.

The fields sidebar shows the number of distinct values in each field. This can help you determine the most suitable aggregation method in your analysis.

Explore the fields sidebar in the Axiom Playground

We've introduced an Event Timeline to Axiom, providing a bird’s eye view of your query results that helps identify spikes, dips, and trends. With one click, you can enable a visual representation of the number of events across a time window.

• Swift insights and event identification: Get an immediate understanding of event distribution over time and easily pinpoint specific events, patterns, or anomalies with the clear visual representation.

• Time range customization: Focus on what’s important by adjusting the time range of your query directly from the histogram.

Simply select your dataset, run a query, enable the Event Timeline, and refine your time range as needed.

Check out the documentation to learn more.

We are excited to announce the latest updates to Axiom’s user interface, making it more user-friendly and accessible than ever before. With a consistent design across the platform, this release focuses on enhancing visual clarity and improving user experience. Here’s what’s new:

• Compact UI: We've refined the interface for a cleaner look and enhanced data density, meaning you can see more on your screen without sacrificing readability.

• Improved contrast: Upgraded theming tokens for better visibility in light and dark modes.

We are excited to introduce field value auto-completion in APL queries, enhancing your query writing experience by providing suggested field values as you type. This feature is designed to boost productivity and reduce errors while writing and managing queries.

An example using the where operator and string operator is included in the image above. As you type your query, the possible values for the method field appear automatically, allowing you to select the correct value quickly.

Our goal is to help you explore data faster, and this is one enhancement that should help with that.

We’re excited to announce the new search operator in APL, a special operator that enhances data search capabilities by performing full-text scans over specified datasets. Instead of limiting you to particular fields or conditions, this feature allows for a broad search across multiple fields.

• Versatility: Search for a specific text or term across various fields within a dataset, without the need to specify each field.

• Efficiency: Save time by quickly locating the data you need.

Check out the documentation to learn more and get started.

We’re excited to announce the enhanced next-axiom library, updated and optimized for Next.js 13. Here are the updated features:

• Integrated AxiomWebVitals for performance metrics.

• Enhanced logging for client/server components and route handlers.

• Comprehensive upgrade guide for transitioning from Next.js 12.

Check out the documentation to learn more and get started.

Axiom Processing Language (APL) is a robust and powerful query language that facilitates the extraction of in-depth insights from your vast pools of data. Be it logs, events, analytics, or other forms of machine data, APL empowers you with the adaptability to filter, transform, and meaningfully summarize your information.

We are continuously enhancing APL by introducing novel functions to optimize your data querying process.

• format_url(): Improves string formatting into valid URLs.

• pair(): Returns a key-value pair separated by specified delimiter.

• parse_pair(): Returns a key-value pair separated by Seperator in Pair. If absent, returns Pair with an empty key.

• array_select_dict(): Selects a dictionary from an array of dictionaries.

• coalesce(): Returns first non-null or non-empty expression from a list evaluation.

• sample operator: Selects random rows for exploration

Check out the APL documentation to learn more.

We’re excited to announce the latest addition to Axiom Dashboards: Table charts functionality, specifically designed to enhance data analysis. Table charts are powerful, enabling you to visualize, analyze, and present complex data with ease. Table charts support common data types, including numerical, textual, and categorical, making it a versatile tool for any analytics workflow.

The current implementation allows you to work with generic data to get valuable insights. This is just the beginning! We have more enhancements in the pipeline arriving soon.

We appreciate your continued feedback on this update within our Discord Community.

AWS PrivateLink allows you to access Axiom securely over the AWS network directly from your VPC without needing an internet gateway or NAT device, simplifying your network setup. Enterprise customers can also opt-into connecting two VPCs within the same region or across different regions, providing a secure and private connection for communication using VPC peering.

For more information about connecting to Axiom over AWS PrivateLink on Enterprise, or if you require support for VPC peering, please contact our sales team.

Kickstart your Axiom journey with our Getting Started walkthrough that guides you step-by-step through the initial setup and onboarding process.

You'll discover how to get up to speed faster and maximize Axiom’s powerful features, like streaming, exploring, and monitoring your data, ensuring a quicker and more seamless experience.

Get started with the onboarding process.

We receive thoughtful product improvement suggestions from our community on Discord all the time. One popular request has been to add dark mode.

We’re delighted to tell you it’s now landed!

You’ll find the option under the top-right menu. It can follow the system theme or force light or dark mode.

Join the Discord and help shape the future of Axiom.

We recently analyzed comments from new users and existing customers about our product documentation. We carefully considered the feedback, then used it to improve navigation in our help system.

These changes have just landed! This is a significant improvement to our document navigation making it even easier for you to find the information you need.

It’s not the end of the road though, we have more work to do, which will land shortly. We welcome your ongoing thoughts on this update in our Discord Community.

Axiom’s new chart variant area enables you to identify log patterns and generate advanced visualizations from your logs using stacked charts. With stacked charts, you can discover trends and compare query patterns from your log data visualization in relative time.

Stacked charts are stacked on top of each other, and by using stacked charts, you can now aggregate your query accurately.

Check out the documentation to learn more.

The Secure Syslog integration now supports web and application logging from cloud application platforms like Render. The Syslog endpoint allows users to send and visualize event logs from static sites, web service, and application workers in just a few clicks.

With this Syslog and Render integration you can:

1. Monitor your static sites

2. Collect and track all available performance logs in your web service

3. Filter errors and sort your logs using Axiom Processing language

Learn more about how to use Secure Syslog on Render.

Axiom Processing Language (APL) is a query language that is perfect for getting deeper insights from your data. Whether you’re working with logs, events, analytics, or other machine data, APL provides the flexibility to filter, transform, and summarize effectively.

We keep making APL better by introducing new functions to improve your data query experience.

Statistical Functions

• make_list()

• make_list_if()

• make_set()

• make_set_if()

Check out the documentation to learn more.

To make APL Queries easier to work with we now support Query Options like strict types to silently enable type hinting for compatible data types behind the scenes.

For example, in normal operation, a field containing a mix of floats and integers can be worked with as if they are all numbers. However, there are times where you want to disable all such conversions, and then strict types query option lets you do this.

Learn more about APL Set Statement

ℹ️ The latest release of axiom-js adds support for the winston logging library:

• Connect one of the best logging libraries for node to Axiom

• Use structured logging to take advantage of Axiom’s advanced querying

Get started here

Collect, transform, and route all your logs, metrics, and traces from Vector and set up Axiom as a sync for your observability data.

With the Vector integration, you can:

• Send data to Axiom from any source

• Ingest and analyze large volumes of data

• Build share queries, build dashboards, setup alerting, and much more

Get started

💡: You can export your middleware, edge, or api Vercel functions withAxiom() to:

• Access logging from the request object

• Capture request properties such as query params etc

• Inspect failed executions with all the details you need

⚡️ Vercel Edge Function support is now live!

All integration users automatically see Edge Function request data from today 📈

For the best experience, upgrade your next-axiom to >= v0.12.1 and use the per-request logging functions:

Get Started

next-axiom now supports @nextjs middleware!

You can now fully:

• Observe all middleware calls

• Measure performance, errors, cache usage

• Log errors & warnings with full structured logging

Get started here

A few weeks ago, we launched our Vercel integration and joined the Vercel marketplace. Axiom provides you with Persistent logging and performance metrics for your Vercel applications and Next.js projects. The Axiom integration enables you to monitor the health and performance of your Vercel deployments by ingesting all your request, function, and web vitals data.

You can use Axiom’s pre-built dashboard for an overview across all your Vercel logs and vitals, drill down to specific projects and deployments, and get insight on how functions are performing with a single click.

You can get and perform other functionalities on your Vercel Applications like:

• Request, function, & static logs

• Function performance + insights

• Custom queries, notifications & alerts

• Unsampled Web Vitals

Install Axiom on your Vercel applications to monitor the health and performance of your deployments

We enabled and deployed one-click login on CLI. With this, you can log in to your Axiom deployments and account resources directly on your terminal using the Axiom CLI.

Read the documentation on enabling One-Click Login

We worked on and deployed a new topk implementation with a scaling factor. With this implementation, you can get the precise estimates when you want to know the top 5 or top 10 (where ‘5’ and ’10’ are ‘k’ in the topk) values for a field in a dataset.

The topK aggregation takes two arguments:

1. The field to aggregate

2. How many results to return (top 5, or top 10, or top 20, etc)

Learn more about this aggregation here

You can now set up and configure a lambda function to run queries using an Application Load Balancer on AWS. Running queries on AWS Lambda can result in lower costs and better performance.

Setting up and Configuring Lambda Queries only applies to Axiom Self-Host installs

Learn more about configuring lambda queries

We deployed the latest version of our REST API docs here. All the endpoints live under the url https://app.axiom.co/api and follow the REST architectural style.

Currently, we documented the endpoints for:

• Datasets

• Querying

• Orgs

• User

Explore the REST API Documentation here

With the latest UI Changes, you can now upload gzipped files using the .gz filename convention.

Click the upload button and drag or drop the file in the box in the Dataset UI

Topk Explore

Using the topk explore button, you can get queries of your specific visualisation directly on Data Explorer.

With the new icons on timestamp and virtual fields you can now view the timestamp icon on _time on your field list drop-down on Axiom Data Explorer.

The Axiom Processing Language (APL) is a query language that is perfect for getting deeper insights from your data.

We keep making APL better by introducing new functions for your data.

• array_concat()

• array_iff()

• array_index_of()

• array_length()

• array_reverse()

• array_rotate_left()

• array_rotate_right()

• array_slice()

• array_split()

• array_sum()

IP Functions

• ipv4_is_in_range()

• ipv4_is_private()

• ipv4_netmask_suffix()

Hash Functions

• hash_md5()

• hash_sha256()

• hash_sha1()

You can now view and copy your organization ID on your Settings page on your Axiom Account. Your Organization ID is under your organization name. Your Ogranization ID must be provided in case a Personal token is used for Axiom CLI and the Client Libraries. It’s not needed when using an API Token.

Your organization’s Avatar is better using the initials of your org.

Get Notified before deleting Token

With the new changes, you will can get the specific detials of your API and Personal Token before delting them on the dashboard.

We added the Cancel button on Analytics and Data Explorer for you to cancel queries and update your changes.

Get notification on query time range before the earliest event or after the latest event

In your Dataset dashboard, you can now see a notification if your query time range begins after the dataset received its last event.

• And a notification if your query time range ends before the dataset received its first event

Our Vercel integration is live but still in beta. using this integration you can analyze, stream, and run queries from your Vercel applications and resources directly on Axiom.

Get in touch with the team to try it out

APL datetime fields are now fully supported

Datetime fields are fully supported on APL, literals of type datetime have the syntax datetime (value), where a number of formats are supported for value.

Read more here

APL: improved support for null types

We have improved support for null types, the scalar function isnull can be used to determine if a scalar value is the null value. The corresponding function isnotnull can be used to determine if a scalar value isn't the null value.

Read more about this feature here

Axiom Data Explorer provides a full auto-completion environment for getting deeper insights from your data. Whether logs, events, analytics, or similar, APL provides the flexibility to filter, manipulate, and summarize your data exactly the way you need it.

The newly published tutorial includes lots of helpful links and guide on how you can discover valuable insights, explore, store, run super-fast queries and monitor high volumes of fresh and historical structured data using Axiom Data Explorer.

Learn about enabling comprehensive monitoring using Axiom Data Explorer

Dashboards are now accessible on Axiom Play. It is a read only dashboard experience that provides you with query information across multiple datasets which are visualized in one place.

Explore this feature