What’s new.

Highlights

• Watch the model being built. A training card shows each boosting round as it happens: the error falling, the features entering the model and the interactions tried.
• The best model wins. When the agent tries to improve a model, it keeps the best version it found rather than the last one, and stops once further attempts stop helping.
• More thorough training. Models now fit three boosting rounds instead of two.
• The right chart for the question. Exploration draws box plots, dot plots with confidence intervals, densities, scatter plots and trends over time where a bar chart would mislead.
• Every word in English. Notes, insights, step descriptions and reports are always written in English, whichever model the run uses.

What Changed

Runs are more resilient. An agent that loops or stalls is stopped and asked to try again. A step that runs out of budget keeps the insights it has already found. An analysis that has already been run returns its earlier result instead of charting it twice. Steps get more room to finish, with higher request limits and more attempts per tool.

Fixes

• A data preparation step that named its columns in two places no longer drops nothing
• New sessions and their dataset appear in the sidebar straight away
• Chart captions show values such as "highest Fiber optic churn rate 0.419" instead of placeholder text
• Model cards label algorithms quietly beside the version: XGM, or Open source for models built with the open-source xplainable library

Highlights

• Levers you control. See every feature the business can change, how much each one moves the outcome, and what it costs. Narrow a lever's range or values, set its cost, or switch it off, then re-measure.
• Scenarios side by side. Build a scenario for a population and a set of actions, run it, and compare scenarios to see which one improves the outcome most for its cost.
• Segments and the budget frontier. Find the segments where the levers work best, and sweep a budget to see how much improvement each extra dollar buys.
• Playbooks. Commit a scenario to a row-level playbook of who to act on and what to do, download it, and record the outcomes once you've acted.

What Changed

A Workbench tab now appears on any agent run that has measured levers. It starts from what the agent found (its levers, scenarios and best result) and lets you refine it without starting a new run. Levers read as a list first and open an editor when you want to change one. Lever templates can be exported and applied to other runs so a team works from the same rules.

Highlights

• Pick the model for each run. Choose Fast (the default), Balanced or Most capable beside the Run button, or search the full list of supported models with their price and context size. Advanced lets you choose a different model for each step of the run.
• Private runs. Turn on Private and every call the run makes, including its chat, goes only to providers that keep no copy of your data (zero data retention).
• Know the trade-off before you run. With Private on, models that can't run privately are greyed out with the reason, and the picker tells you which providers remain, so you know what you're giving up in choice and speed.
• See what a run cost. The run page shows spend so far against the run's budget, broken down by step and by model, along with the model and provider behind each step.

What Changed

Every agent run used to use the same model. You can now choose one per run, from a short list of recommended options or the full catalogue. The list is kept up to date automatically with each model's current price and whether it can run privately.

Private runs are for data that must not be kept by a third party. When a run is Private, every request is held to zero-data-retention providers. A model that can't meet that is refused before the run starts, with a clear explanation, rather than partway through. Private runs carry a shield badge on the run page so you can tell at a glance.

Run costs are now complete and exact. Every model call a run makes is counted at the provider's billed price, including the chat, the evaluation that decides whether to keep improving the model, and steps that stop early. The budget is checked against that same figure before every request.

Highlights

• Start from a goal, not a form. Ask a question in plain English ("Give me a row-level action list of who to act on, under a budget") and the agent picks the route: understand the data, predict an outcome, find the levers that change it, or build an action list.
• Watch the work as it happens. Each step appears as it runs: data readiness, charts and insights, the plan, every preparation step, the model training round by round, the evaluation, the deployment, the levers and scenarios, and the final playbook.
• Auto or Guided. Let the agent run end to end, or switch to Guided and approve the route, the plan and the deployment before they happen. You can edit the plan before approving it.
• Talk to a run. While a run is working, send it a note: point it at a column, suggest a preprocessing step, or a constraint to respect. It answers in the run and picks your note up at its next step. When a run has finished, ask it questions about the data, the model or the results, or ask it to continue, rewind to an earlier step, or update the report.
• A report at the end of every run, written from the run's own numbers and charts. Ask for a version for a particular reader and it is saved as a new version of the same report.

What Changed

The agent page has been rebuilt around what a run actually does. The centre of the page follows the run step by step, with a card for each result. The panel on the right shows where the run is up to, how long each step took, the route still to come, and what the run has cost so far.

A new Trace tab shows how the agent worked: every model turn and tool call, with a timeline of where the time went and a replay scrubber.

The agent also names and describes the model it builds, based on what it is trained to predict, so your models list reads like your business rather than your prompts. Model cards show the familiar model profile again: headline metrics, what drives predictions, the model profile, threshold analysis and performance curves.

Highlights

• Declare derived columns, category dependencies and monotonic directions once per dataset, and every model trained afterwards inherits them
• Get suggested relationships from your data, with evidence, before you commit to them
• Optimisation no longer recommends combinations that cannot exist, in either direction
• Derived values stay consistent when a recommendation changes one of their inputs
• Monotonic constraints now hold across the whole model, including interaction effects

What Changed

Models learn each feature on its own, so they have no way of knowing that a lifetime value column is calculated from tenure and monthly charges, or that a customer without an internet plan cannot have an internet add-on. Left undeclared, prescriptive optimisation can suggest changes that look good on paper but cannot be actioned.

You can now declare these relationships against a dataset. Ask xplainable to scan the data and propose candidates, each with supporting evidence, then keep the ones that are true for your business and discard coincidences. Every model trained on that dataset then carries the rules, and optimisation respects them automatically. Existing models can pick up an updated declaration without retraining.

Monotonic constraints have also been strengthened. A direction you set on a feature now applies to its full effect, including any interactions it takes part in.

Fixes

• Refitting individual features no longer produces a silently degraded model
• Model versions report the correct linked preprocessor and their training parameters
• Requesting a model that does not exist returns a clear message instead of an error
• Agent sessions that lose their team selection now explain how to reconnect

Highlights

• Open source — The xplainable MCP server is now public on GitHub under the MIT license. Run it locally with a single command, or connect to the hosted server at
  python⧉ copy

  mcp.xplainable.io

  .
• New workflow tools — Nine goal-oriented
  python⧉ copy

  workflow_*

  tools cover the entire model lifecycle: find data, train with human-in-the-loop approval gates, deploy, predict, optimise, explain, and generate reports.
• A curated surface built for agents — By default the server exposes a focused set of 28 tools instead of the full 104-tool API surface, so agents pick the right tool and burn less context. Power users can opt into the full surface with one environment variable.
• Coached errors — Workflow tools never return raw API errors. Every failure comes back with a plain-language message and a suggested next step, so agents recover on their own.

The workflow loop

Ask your AI assistant to build a model and it works through a natural loop:

1. python⧉ copy

   workflow_list_assets

   — see your datasets, models, and deployments
2. python⧉ copy

   workflow_train_model

   — kick off a training run on the Xplainable platform
3. python⧉ copy

   workflow_wait_for_update

   +
   python⧉ copy

   workflow_decide

   — the agent narrates progress and relays approval gates (label selection, training approval) to you
4. python⧉ copy

   workflow_deploy_model

   — deploy and get an endpoint, key, and sample payload
5. python⧉ copy

   workflow_predict

   ,
   python⧉ copy

   workflow_optimise_model

   ,
   python⧉ copy

   workflow_explain_model

   ,
   python⧉ copy

   workflow_create_report

   — put the model to work

Training runs server-side on the Xplainable platform — the agent orchestrates, you approve the important decisions, and every model remains fully transparent and explainable.

Run it locally

Connect Claude Code with one command:

bash⧉ copy
claude mcp add xplainable \
  -e XPLAINABLE_API_KEY=your-api-key \
  -- uvx --from git+https://github.com/xplainable/xplainable-mcp-server.git xplainable-mcp

Claude Desktop, Cursor, and other MCP clients are supported too — see the README for setup guides. This release ships alongside xplainable-client 1.8.0 on PyPI, which adds the underlying workflow layer.

Highlights

• Custom roles — Create your own roles with fine-grained permissions across 10 resource types (models, deployments, datasets, monitors, reports, and more), each with four access levels: Full, Edit, View, or None.
• Redesigned admin panel — A new settings sidebar with six dedicated sections: Members, Teams, Roles, Billing, Audit Log, and Security.
• Audit logging — Every admin action (invites, role changes, offboarding, team updates) is now tracked with a searchable, filterable audit trail.
• Role preview mode — Owners and admins can preview the app as any role to verify what their team members see.

What Changed

The workspace admin panel has been completely rebuilt from the ground up. Instead of a simple creator/viewer toggle, permissions are now managed through a full role-based system. Four system roles (Owner, Admin, Creator, Viewer) come built-in, and you can create unlimited custom roles tailored to your team's needs.

Each role defines access across 10 permission keys, so you can give someone full access to models but read-only access to deployments, or let them manage reports without seeing billing. Role assignment follows a hierarchy — you can only assign roles at or below your own level.

The new Members section includes bulk actions, inline role editing, an offboarding workflow with ownership transfer, and seat-aware invitations. Teams now support custom icons and a member picker with external invite support. The Audit Log tracks every admin action with filtering by category and a detail drawer for each event.

All changes apply across the entire app — navigation, route access, and feature visibility all respect the new permission system automatically.

New documentation sections

• Python SDK — Dedicated reference pages for XClassifier, XRegressor, and Preprocessing with typed parameter tables and code examples
• REST API — Complete reference for all 12 API modules (Models, Deployments, Inference, Datasets, Monitors, Auto-Train, and more). Auto-updates when the client package changes.
• MCP Server — Documentation for all 67 MCP tools with an interactive tool call simulator. Includes hosted endpoint setup with OAuth and configuration guides for Claude Desktop, Cursor, Windsurf, Cline, and Claude Code.
• Tutorials — 13 end-to-end tutorials from Jupyter notebooks covering classification, regression, and real-world datasets

AI-powered documentation search

The xplainable MCP server now includes tools that let AI agents search and read the docs directly:

• python⧉ copy

  docs_list_pages

  — Browse all pages by category
• python⧉ copy

  docs_get_page

  — Fetch the full content of any page
• python⧉ copy

  docs_search

  — Keyword search across titles, headings, and content

Ask your AI assistant about xplainable and it will read the docs for you. No hallucinated endpoints, no outdated examples.

Auto-updating docs

All generated documentation (REST API, MCP tools, tutorials, and the search index) updates automatically via GitHub Actions whenever the underlying source code changes.

Highlights

• 60% faster pipeline execution through cross-phase pre-generation that eliminates wait times between steps
• Smarter, label-aware recommendations for data preparation and feature engineering powered by automated data analysis
• Real-time chart rendering as each visualization completes, no more waiting for all charts to finish
• Skip what you don't need with a new option to bypass chart generation and jump straight to label selection

What Changed

The agent now pre-generates recommendations for the next step while you review the current one. Label suggestions load while you browse charts, data prep recommendations are ready the moment you select a target, and feature ideas appear instantly after data prep finishes.

Recommendations are now informed by your selected target variable, with correlation analysis, class balance detection, and skewness checks feeding directly into what the agent suggests. The result is fewer irrelevant steps and more impactful transformations.

Training is more resilient too. If a model fails to train, the agent automatically diagnoses the issue, adjusts the feature set, and retries without manual intervention. You also get a redesigned training approval screen with feature metadata so you can see exactly what goes into your model before it trains.

Highlights

• Status code tracking for every inference prediction (200, 404, 422, 500)
• Deployment health summaries available in a single query
• Error monitoring through MCP for agentic workflows
• Sparkline activity indicators on deployment cards

What Changed

Every inference prediction now records its HTTP status code, latency, and error details. You can see this breakdown directly on the deployment monitoring page as a stacked area chart showing successful and failed requests over time.

Deployment cards on the overview page now include a sparkline showing request volume over the last 24 hours, along with a request count and error count that turns red when failures are detected.

For teams using agentic workflows, new MCP tools let AI agents check deployment health and diagnose errors programmatically. A single call to the deployment health tool returns total requests, success rate, average latency, status code distribution, and recent error messages, giving agents everything they need to identify and report issues without manual dashboard checks.

Highlights

• New xp command with ~50 commands across all xplainable services: models, deployments, preprocessing, optimisation, and more
• Purpose-built for AI agents: JSON output by default, structured exit codes, and clean separation of data and errors
• Reduces AI agent token usage by up to 97% compared to MCP-based tool integrations
• Zero new dependencies required

Why This Matters for AI Workflows

When AI agents like Claude or ChatGPT connect to APIs via MCP (Model Context Protocol), every tool schema is injected into the context window on every turn, whether used or not. With 47 tools, that is roughly 4,000 tokens per turn, adding up to 200,000+ tokens in a typical session.

The xp CLI flips this model. Because it runs as a standard shell command, it adds zero tokens to the context when idle and only a fraction when invoked. In a 50-turn session with 3 API calls, the CLI uses roughly 180 tokens of overhead versus 200,000 for the equivalent MCP setup.

Getting Started

Install or upgrade the client library, set your API key, and start using it:

python⧉ copy
pip install --upgrade xplainable-client
export XPLAINABLE_API_KEY=xp_...
xp models list --pretty

The CLI supports --pretty for human-readable output and -q for minimal output, with compact JSON as the default for machine consumption.

Highlights

• Fully guided AI training pipeline that takes you from raw data to a deployed model with intelligent automation at every step
• Smart data-aware visualizations that analyze your dataset and generate charts tailored to your actual columns and distributions
• Interactive decision points where you stay in control of key choices like label selection, feature engineering, and deployment
• Automated feature engineering that creates new features from your existing data to improve model performance
• Built-in chat interface for querying your data, interpreting model results, and getting actionable predictions in natural language
• One-click deployment, monitoring, and reporting to take your model from training to production in a single workflow

What's New

Agentic Auto-Train is a fundamentally new way to build machine learning models on xplainable. Rather than manually configuring each step of the pipeline, an AI assistant now guides you through the entire process from data upload to deployment. The system analyzes your dataset, makes intelligent recommendations, and adapts to your decisions at every stage.

Upload your data and the assistant immediately gets to work. It scans your dataset for quality issues, identifies column types, checks for missing values, and surfaces a health summary so you understand exactly what you're working with before training begins.

Intelligent Label Selection

The system analyzes every column in your dataset and recommends the most suitable prediction targets, ranked by confidence. Each recommendation comes with a clear explanation of why that column is a good candidate, along with key statistics like unique values, null rates, and class balance. You choose the label that fits your goal, and the pipeline adapts accordingly.

Data-Aware Visualizations

Instead of showing generic placeholder charts, the system now examines your dataset's structure and generates visualizations that are specific to your data. It identifies the most meaningful distributions, correlations, and feature relationships, then creates tailored charts that reference your actual column names and data characteristics. Each visualization comes with a title explaining what insight it's exploring and why it matters.

Automated Feature Engineering

The AI assistant reviews your dataset and generates new engineered features designed to improve model performance. It creates transformation code for each feature, explains the rationale behind each one, and presents them for your review. You can approve individual features, skip ones that don't make sense for your use case, or let the system apply its full set of recommendations.

Interactive Decision Points

Throughout the pipeline, you're presented with clear decision cards at every critical juncture. Whether it's selecting a prediction target, approving engineered features, reviewing preprocessing strategies, or confirming deployment settings, you always have visibility into what the AI is recommending and the ability to adjust course. The pipeline pauses at each decision point and waits for your input before continuing.

Comprehensive Model Overview

Once training is complete, you get a detailed model profile that goes beyond simple accuracy numbers. The overview includes performance metrics across multiple evaluation criteria, a breakdown of the top contributing features, and key insights about what the model learned from your data. You can see at a glance which features matter most and how the model is making its predictions.

Prediction Testing with Waterfall Breakdown

Test your model directly in the interface by entering values for each feature. The system returns a prediction along with a detailed waterfall chart showing exactly how each feature contributed to the result, both positively and negatively. Alongside the prediction, you get actionable recommendations highlighting which features have the most room for improvement and what direction would shift the outcome.

Chat with Your Data and Model

A built-in conversational interface lets you interact with your data and model using natural language. Ask questions about your dataset and get instant query results. Request new visualizations and they're generated on the fly. Ask the model to interpret its own behaviour or run what-if predictions. Responses stream in real time with rich formatting, inline charts, and structured data tables.

Deploy, Monitor, and Report

When you're satisfied with your model, deploy it with a single click directly from the training workflow. Set up automated monitoring to track model performance over time and catch drift early. Generate detailed reports summarizing your model's capabilities, training process, and key findings. The entire journey from raw data to production-ready model happens within one continuous, guided experience.

How It Works

1. Upload your dataset and the AI assistant begins analyzing it immediately
2. Review data health metrics and quality summaries
3. Explore auto-generated visualizations tailored to your data
4. Select a prediction target from ranked recommendations
5. Approve engineered features and preprocessing strategies
6. Train your model with optimized settings
7. Evaluate performance with detailed metrics and feature breakdowns
8. Chat with your model to test predictions and explore insights
9. Deploy to production and set up monitoring, all in one flow

Highlights

• Step-by-step monitor creation with a guided wizard that walks you through model selection, data upload, and configuration
• Upload and run directly from the dashboard without needing to leave the monitor page or use external tools
• Snapshot comparison to compare results across different runs and track how your model's predictions change over time
• Automated alerts with email notifications using threshold, trend, and volume rules so you're notified when something needs attention
• Operational health dashboard showing successful runs and triggered alerts at a glance
• Plain language labels throughout, replacing technical jargon with terms like "Likelihood", "% Above Threshold", and "Item #"

What Changed

The Monitors section has been rebuilt to make it easier for anyone on your team to track model performance, not just data scientists. You can now create a new monitor in just a few steps using the creation wizard, which guides you through selecting a model, uploading your initial dataset, and reviewing your configuration before saving.

Once a monitor is set up, you can upload new data and trigger runs directly from the monitor page using the new "Upload and Run" button. A snapshot selector lets you switch between historical runs to see how predictions have shifted over time.

Alert rules let you define conditions that matter to your business. Set a threshold, track trends, or watch for volume spikes. When a rule triggers, you'll receive an email notification with the key details so you can take action quickly.

The monitors overview page now displays a timeline of run activity alongside cards showing your total successful runs and alerts triggered, giving you a clear picture of operational health across all your monitors.

We've also improved how empty states are displayed so new monitors look clean before their first run.