​

Evaluate multi-step agents with new query filters

• Span relationships — combine up to five named span filters with operators such as => (direct parent), -> (happened before), AND, and OR to express how spans connect, not just that they coexist.
• Variable mapping by span role — map each evaluator input (for example, question, context, and answer) to the subquery that should supply it.

​

Easily view full sessions from labeling queues

• View Trace or View Session — choose the level of context directly from the queue record’s source-data menu.
• Originating trace highlighted — the session view scrolls to and highlights the trace the queue record came from.

​

Fixes and improvements

• Fix Session-level evaluators can now be run from the Use Evaluator slideover, which previously left the Run button disabled.
• Fix Online tasks running multiple span-level evaluators now stamp each eval span with its own eval name, so eval results filter correctly in dashboards.

• Fix Experiment runs launched from the playground no longer fail when template variables are supplied through per-example overrides.

• Improvement External audio attachments now play in the span view even when the waveform preview can’t be generated.
• Fix Clicking the text inside a rich-text table cell now activates the row, matching the rest of the row’s click behavior.

• Improvement Alyx now recovers gracefully from query timeouts with a retry prompt instead of failing.
• Fix Large synthetic datasets generated by Alyx now render their apply widget reliably instead of stalling.
• Improvement Alyx now asks follow-up questions through interactive prompts and places reference links at the end of its responses.

• Improvement The Python SDK’s list_examples() method now supports cursor pagination, so you can export large datasets in batches instead of loading every example at once. See the Datasets client documentation.
• Fix The Python SDK no longer writes datasets to the local cache when caching is disabled, restoring list_examples() and list_runs() on read-only filesystems such as AWS Lambda.
• Improvement The annotation endpoints (annotate for spans, dataset examples, experiment runs, and annotation queues) graduated from alpha to beta in the Go and TypeScript SDKs.
• Improvement The Python SDK now tailors its async-execution guidance to your Python version, recommending sync execution on Python 3.14+ where nest_asyncio is unsupported.

​

The Go SDK v2 is now generally available with full feature parity

package main

import (
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
)

func main() {
    client, err := arize.NewClient(arize.Config{
        APIKey:  "YOUR_API_KEY",
        APIHost: "api.arize.com",
    })
    if err != nil {
        log.Fatal(err)
    }
    _ = client
}

​

Populate annotation queues with traces

​

See active traces as they run with in-progress trace support

• Active traces — long-running workflows appear in the table while still executing, not just after they complete.
• Orphaned spans surface immediately — when the root span hasn’t arrived yet, the earliest span holds the row until it does.
• Status labels — each trace is clearly marked complete, in-progress, or orphaned.

​

Add Claude Fable 5 to your prompts and evaluations

• Anthropic provider — select Claude Fable 5 anywhere you choose a model, backed by your Anthropic integration.
• Cost tracking included — input, output, and cache token pricing for Claude Fable 5 is preloaded for both Anthropic and Vertex AI.

​

Reuse Custom Metrics across models, projects and dashboards

• Space-level management — create, edit, and browse all custom metrics from the Custom Metrics page in the sidebar.
• Per-model flow removed — the Custom Metrics tab on individual model and project overview pages, along with the per-model create and edit pages, is no longer available; recreate any metrics you still need at the space level.

​

Append runs to an existing experiment from the SDK

• Up to 1,000 runs per request — each run references an existing example by example_id and supplies its output, plus any extra fields you want to record.
• Run IDs returned in order — the response includes the IDs of the newly created runs in input order.

from arize import ArizeClient

client = ArizeClient(api_key="YOUR_API_KEY")  # or set ARIZE_API_KEY

# Each run targets an existing example in the experiment's dataset
new_runs = [
    {"example_id": "ex-1", "output": "Paris is the capital of France"},
    {"example_id": "ex-2", "output": "Rome is the capital of Italy"},
]

experiment = client.experiments.append_runs(
    experiment="experiment-name-or-id",
    dataset="dataset-name-or-id",   # required when 'experiment' is a name
    space="your-space-name-or-id",  # required when 'dataset' is a name
    experiment_runs=new_runs,
)

# IDs of the newly appended runs, in input order
print(experiment.run_ids)

import { appendExperimentRuns } from "@arizeai/ax-client";

const result = await appendExperimentRuns({
  experiment: "your_experiment_name",
  dataset: "your_dataset_name", // required when 'experiment' is a name
  space: "your_space_name_or_id", // required when 'dataset' is a name
  experimentRuns: [
    { exampleId: "your_example_id_1", output: "The answer is 42" },
    { exampleId: "your_example_id_2", output: "Paris" },
  ],
});

// IDs of the appended runs, in input order
console.log(result.runIds);

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/experiments"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    // AppendRuns references the experiment by ID
    result, err := client.Experiments.AppendRuns(context.Background(), experiments.AppendRunsRequest{
        ExperimentID: "your-experiment-id",
        ExperimentRuns: []experiments.ExperimentRunCreate{
            {ExampleId: "example-1", Output: "An AI observability platform."},
            {ExampleId: "example-2", Output: "A unit of work in a trace."},
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    // RunIds holds the newly appended run IDs, in input order
    fmt.Printf("appended %d run(s) to experiment %s\n", len(result.RunIds), result.Id)
}

​

Manage evaluation tasks directly from the Go SDK

• Full lifecycle — list, get, create, update, and delete evaluation and run-experiment tasks.
• Async run control — trigger runs over a chosen data window, poll until completion, and cancel in-progress runs.

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/tasks"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }
    ctx := context.Background()

    // Create a task that scores incoming LLM spans with your evaluator
    task, err := client.Tasks.CreateEvaluationTask(ctx, tasks.CreateEvaluationTaskRequest{
        Name:    "llm-correctness",
        Type:    tasks.TaskTypeTemplateEvaluation,
        Project: "your-project-name-or-id",
        Space:   "your-space-name-or-id", // required when Project is a name
        Evaluators: []tasks.EvaluatorInput{
            {EvaluatorID: "your-evaluator-id"},
        },
        QueryFilter: "attributes.openinference.span.kind = 'LLM'",
    })
    if err != nil {
        log.Fatal(err)
    }

    // Trigger an on-demand run over the last hour of spans
    run, err := client.Tasks.TriggerRun(ctx, tasks.TriggerRunRequest{
        Task:          task.Id,
        Space:         "your-space-name-or-id",
        DataStartTime: time.Now().Add(-time.Hour),
        DataEndTime:   time.Now(),
        MaxSpans:      1000,
    })
    if err != nil {
        log.Fatal(err)
    }

    // Poll until the run reaches a terminal state
    final, err := client.Tasks.WaitForRun(ctx, tasks.WaitForRunRequest{RunID: run.Id})
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("run %s finished with status %s\n", final.Id, final.Status)
}

​

Plan for the API key status rename from “deleted” to “revoked”

• Update filters — replace deleted with revoked wherever you query or display API key status.
• SDK enums updated — the ApiKeyStatus enum in the Python, TypeScript, and Go SDKs now uses revoked.

from arize import ArizeClient

client = ArizeClient(api_key="YOUR_API_KEY")

# "revoked" replaces the former "deleted" status value
resp = client.api_keys.list(status="revoked")

for key in resp.api_keys:
    print(key.id, key.name, key.status)

​

Create and edit labeling queues conversationally with Alyx

• Conversational setup — ask Alyx to create or update a labeling queue and review the proposed configuration before accepting it.
• Jump to the queue — open the created queue directly from a link in Alyx’s response.

​

Edit and resend messages in an Alyx conversation

• Edit in place — hover any message to edit and resend it.
• Safe branching — when a response included a widget, editing forks the thread and archives the original so earlier results are preserved.

​

Fixes and improvements

• Improvement Running a single evaluator now opens the run confirmation modal scoped to that evaluator instead of firing the run immediately.
• Fix The back button on the evaluator detail page returns to the previous page correctly.

• Fix Data quality monitors persist comparison-window filters even when the primary window has none.
• Fix Clearing a monitor’s evaluation-window input no longer resets it to zero.
• Fix Unsaved new widgets are discarded when the edit form is closed.

• Fix Session- and trace-level eval counts no longer overcount in span-level aggregations.
• Fix The CONTAINS filter on string-list columns matches list elements case-insensitively, so trace and dashboard counts agree.

• Fix You can remove a stuck prompt from Alyx’s context.
• Fix Alyx no longer emits runaway text when a model returns a stop signal as plain text.
• Fix Creating evaluators and fixing variable mappings works from the trace slideover and sessions page.

• Improvement The Python SDK SDKConfiguration accepts default_headers to attach custom headers to all HTTP, gRPC, and Flight requests.
• Improvement ax api-keys refresh accepts --grace-period-seconds to keep the previous key valid during rotation.
• Improvement Flight-backed export commands (spans, datasets, experiments, traces) support --all under OAuth authentication.
• Fix Dataset ingest rejects raw binary columns with a clear error before upload instead of failing mid-import.
• Fix Triggering a task without a configured LLM integration returns HTTP 400 with a clear error instead of HTTP 500.
• Fix Corrected the ax CLI snippets shown in the in-app code modals.

• Fix Table-source ingestion jobs (Snowflake, BigQuery, Databricks) are no longer auto-paused prematurely when polling with no new data.

​

Continuously investigate production agent failures with Signal

​

Orchestrate repo-aware managed agents across your engineering workflows

​

Track managed agents in your organization from a single view

​

Agent Experimentation surfaces behavioral diffs across your complete agent system

​

Adapt your evaluation criteria to emerging agent failures with Agent-as-a-Judge

​

Observe, replay, and evaluate voice agent conversations natively

​

Design custom views for annotation queues with Alyx

​

Monitor org-wide traces, costs, and evals at a glance

• Trace Count Over Time: stacked bar chart of root span volume across spaces, with per-day top-project tooltip drilldowns
• Errors Over Time: stacked bar chart of spans with status_code=ERROR, broken down by space and top contributing projects
• Average Latency Over Time: line chart of average latency by space with per-project tooltip drilldowns
• Total Cost Over Time: stacked bar chart of daily cost aggregates by space
• Average Eval Score Over Time: line chart with an org-level eval picker across all LLM projects
• Distribution of Eval Labels: bar chart of eval label distributions with eval and scope selection

​

Keep your Alyx conversation thread as you move across the platform