Product updates
What’s new in Prefactor. Features, improvements, and fixes shipped to the platform and SDKs.
The changelog lists what shipped in Prefactor, grouped by month and filterable by category — platform, SDK & CLI, observability, evaluation, governance & compliance, integrations, and more.
Run the CLI login, approve it in your browser, and you are signed in. No more copying and pasting tokens.
The browser shows the device and terminal details asking to sign in, so you can check it is really you before you approve.
Signing up is shorter and clearer, with a new account setup step, a few optional questions about you, and a progress screen while we prepare your sample agent.
Choose a personal, business, or nonprofit account, enter a promo code if you have one, and skip the questions if you would rather get straight in. People who belong to several accounts get a cleaner account picker.
The app has a new colour palette in light and dark mode, and forms, menus, and schema cards now fit properly on a phone screen.
Three new API and CLI checks catch mistakes before your agent sends real data: validate a JSON schema, preview a summary template against sample payloads, and check sensitive-data markers.
Each check returns field-level errors, so you can fix a schema or template without registering an agent to find out it is wrong. Pass inputs inline or from files in the CLI.
Send Prefactor events to a Slack channel: new agents and instances, alerts, teammates joining, tokens, and more. Choose exactly which events you want.
Set it up from the new Integrations page in account settings, pick events in groups or one by one, and send a test message to check it works. Messages link straight back to the agent, instance, or alert in Prefactor. The same settings are available through the API and CLI.
Set up a judge to score your agents’ runs against a criterion you write. Its verdict lands on the run’s Quality tab, alongside your other quality measures.
A judge is an agent with its own section in the app. Start from a built-in template, write the criterion in plain language, pick a model from one of your connected LLM providers, and Prefactor hosts and runs it for you. You can also bring your own judge agent through the SDK.
Attach a judge to the agents it should score, and run it on demand or automatically whenever a run finishes. The setup dialog walks you through your first judge and tells you if a model is still missing.
Store the documents your agents rely on in knowledgebases, with every change kept as a revision, through the API and CLI.
Each edit to a document or knowledgebase creates a new revision, so you can always see what your agents had to work with at any point. Archive documents or whole knowledgebases to freeze them without losing their history.
Pick a paid plan straight from the Usage tab, and manage an existing subscription through the billing portal, without talking to us first.
The plan table sits next to your usage so you can see what you are using before you choose. Once you are on a paid plan, a Manage subscription link opens the billing portal to change plans, update payment details, or download invoices.
Inviting a teammate now sends them an email, and you can resend a pending invite from the account page, the API, or the CLI.
The invite list shows whether each email was sent. New users also get a welcome email when they join.
Add your Anthropic, OpenAI, Ollama Cloud, or Together AI account to Prefactor from the new LLM providers tab, and choose which models are available to use.
Model lists, names, and pricing come from models.dev, so new models show up without waiting for a Prefactor release. Providers you connect here power hosted judges.
Agent instances can now carry what a run was asked to do, what it produced, and any metadata you want to keep with it, each checked against a schema you define.
Define params, result, and metadata schemas on your agent schema version, send the payloads when an instance starts and finishes, and see them on the instance page. They are stored with the same sensitive-data handling as span payloads and can be redacted after the fact.
The conversation view now shows each assistant turn and each LLM call as its own item, and keeps cancelled, failed, and empty messages instead of hiding them.
Every conversation now has clear turn markers, even for frameworks that do not report turns themselves, so it is easier to follow what the agent did step by step. Conversations from the Vercel AI SDK 2.0 middleware also display correctly.
Switch between the last 24 hours, 7 days, or 30 days from the header, and every chart, list, alert, and quality view follows.
The range you pick stays with you as you move between pages and tabs, and is part of the URL, so a link you share opens on the same window. The API and JSON-RPC queries accept the same time-range filters.
Teammates, invites, and API tokens can now be given read-only access, so people and tools can look at your agents without being able to change anything.
Choose read-only or full access when you invite someone or create a token. Existing users and tokens keep full access, so nothing changes until you decide it should.
A new Usage tab on your account shows how many spans you have sent each day, your monthly total against your plan allowance, and your current plan and billing period.
Step back through previous months, and see markers on the chart wherever your plan changed. Accounts without a paid subscription are shown on the free Developer plan with its span allowance.
Environments and agent instances can now carry an external identifier, so you can look them up in Prefactor by the IDs you already use in your own systems.
Set an external identifier when you create, register, or update an environment or instance, then fetch it by that ID through the API or CLI. Identifiers are unique within your account, the same way agent external identifiers already work.
An agent can now carry several named quality schemas instead of one, so you can track accuracy, tone, cost, or any other measure side by side on each run.
Each quality payload is checked against its own schema and shown as its own table on the instance page. Tables use the labels and descriptions from your schema, with help tooltips, formatted numbers and dates, and rich text for Markdown fields such as reviewer comments.
In the API, quality_schema and quality_payload are now quality_schemas and quality_payloads, keyed by name. Update to the latest SDK to use them.
Signing in now lands you on a home page with the last 24 hours at a glance, activity across your account, and every agent sorted by most recent activity, with agents that need attention marked.
Each agent in the list has its own activity graph and updates live as spans arrive. Accounts without agents see a clear path into Getting Started instead.
The app also has a new frame: a full-width header holding the account switcher and help menus, clickable breadcrumbs on every page, and a slimmer sidebar.
Alerts raised by your agents now show up where you work: an Alerts tab on each agent instance with a live count, an Alerts column on the agent page, and a detail view with the full history of every alert.
The alert detail view shows the payload and every raise, update, and clear, so you can see exactly what went wrong and when it recovered.
Agents running with a deployment token can now raise and clear alerts on their own instances, so an agent can flag a problem it sees and clear it once it has recovered.
New accounts start with a ready-made Support Chatbot agent, complete with sample conversations, traces, and quality feedback, so you can see what Prefactor shows before you connect your own agent.
The sample agent is a normal agent in your account. Open its conversations, step through its traces, and see how quality scores and feedback appear on the agent page, without writing any code first.
Getting Started now asks whether you are creating a new agent or connecting an existing one, then gives you a short setup prompt to paste into your coding tool.
Your coding tool runs prefactor setup, writes the environment values, instruments the agent, checks that traces arrive, and offers to install the Prefactor skills. A Setup agent button on the agent page, including on empty agents, takes you straight into the same flow.
Agents can now raise alerts when something needs a person. Define alert schemas per agent, raise and clear with severity and a structured payload through the API and CLI, and get every lifecycle event recorded as a span so the history is auditable.
Alerts are raised and cleared by name against an agent instance, so an instance only ever has one live alert per condition — re-raising updates it in place instead of piling up duplicates. Each alert carries a severity from info to critical, a payload validated against an alert schema you define alongside your span schemas, and a short summary rendered from the schema's template with sensitive fields redacted.
Every raise, clear, and update also writes an alert span, including which fields changed — so an alert's full history is reconstructable from the span stream and you can prove what was raised, when, and why. List, read, raise, and clear through the REST and JSON-RPC APIs or the CLI, with filtering by agent, instance, environment, status, severity, and name.
The quality tab now renders an instance's quality payload as a sorted key-value table — measures on the left, results on the right, nested values pretty-printed — with the template summary kept up top. No more reading raw JSON.
The conversation view now shows a risk level beside every item in the exchange, so you can scan a whole conversation and spot the step that needs a closer look without opening each span.
Indicators appear on user and assistant messages, thinking, tool calls, tool results, and custom spans, with the numeric risk score on hover when one is present.
Every span now carries a purpose — activity or quality — visible in span details and filterable in the API and CLI, so you can watch what an agent did and evaluate how well it did it without the two muddying each other.
Changes to an instance's quality payload are now recorded as quality spans, so the evaluation trail is part of the same stream as everything else the agent did. Activity metrics, risk, and histograms exclude quality spans, keeping your operational signals clean.
A dedicated Conversation API now powers the instance conversation view, with mappers for Claude SDK, LangChain (Python and TypeScript), and LiveKit spans, plus a visual lift for the chat components.
Whatever framework your agent is built on, the platform maps its spans into one consistent conversation: messages, tool calls, and results in the order they happened.
Mark every agent instance as live, smoke test, or eval; register a quality schema per agent; and attach quality payloads to instances, surfaced in the UI so you can evaluate runs against the outcomes you said matter.
Agents also gain an external identifier property, so instances can be tied back to the systems that launched them.
Sensitive values are separated from span payloads at the source and shown redacted by default, so agent telemetry can be watched and shared without exposing what your agent touched. The sensitive half is stored apart from the span and can be discarded on its own.
The sensitive data model spans the whole pipeline: SDKs flag encoding per span, payloads are split and recombined on the platform, the sidecar can be discarded independently of the telemetry it annotated, and the UI renders sensitive JSON with values hidden until deliberately revealed.
A reworked first-run experience that takes you from an empty workspace to your first instrumented agent with less friction.
A new setup command scaffolds a working configuration, the ping endpoint tells you exactly what your token can do, and the Python SDK validates its token at startup instead of failing on the first span.
Also fixes a TypeScript SDK shutdown hang after a fatal telemetry error, so processes exit cleanly even when the transport has given up.
Agent sessions driven through GitHub Copilot in VS Code, ingested over OpenTelemetry, now show the user's request, a proper conversation view, and a per-instance cost breakdown.
The conversation view understands the OpenTelemetry spans Copilot emits, surfaces the user message from the invocation payload, and breaks down cost per instance. Model lookups strip dated build suffixes, so cost attribution keeps working as models roll forward.
Agents built on the Vercel AI SDK now get the full conversation view: messages, tool calls, and compact rendering for custom spans.
Pull the full context of an agent instance, its spans, inputs, and outputs, through a dedicated endpoint, straight from the CLI. Built for reviewing what an agent actually did.
Model the humans around your agents. Create people and teams, connect agents to owners and owning teams, browse team overview pages, and navigate agents grouped by team.
A dedicated quality tab on every agent: the home for evaluating how well an agent's output holds up, not just whether it ran.
Define risk profiles, agree a maximum acceptable risk per agent, and watch live risk roll up from instance to agent to overview. The redesigned risk summary shows where an agent stands against what you agreed.
Risk profiles are now first-class: a dedicated section of the app, profile details in the agent header, and an edit dialogue for tuning them. Each agent carries an agreed maximum acceptable risk, instances display their own risk, and risk rolls up to the agent overview so drift from the agreed level is visible at a glance.
Stop a running agent instance remotely. Termination requests flow from the platform over the WebSocket API, and both SDKs now honour them.
Every agent instance now shows token usage and cost computed from model pricing: prove what each run costs instead of guessing.
Watch voice agents the way you watch text agents. LiveKit integrations for both SDKs capture sessions, turns, and tool use from real-time voice pipelines.
A shell installer for the Prefactor CLI: one command fetches the right binary for your platform and gets you to a logged-in prompt in seconds.
Both SDKs can now report data risk categories directly from agent code, feeding the platform's risk picture with what your agent actually touches, plus an agent skill that walks coding agents through wiring it up.
The data risk APIs let an agent declare the categories of data it handles as it runs, so risk on the platform reflects observed behaviour rather than assumptions. A bundled skill teaches coding agents to instrument this for you.
An SDK telemetry problem now stays contained instead of bringing your agent down with it. Malformed bearer tokens are rejected cleanly at the API, and platform views recover gracefully when a load fails.
JWT parsing on the API now handles malformed bearer tokens without raising. The TypeScript SDK hardens transport failure handling and the Python SDK degrades gracefully on errors: telemetry problems are contained inside the SDK rather than surfacing in your agent. Live views on the platform handle load errors gracefully instead of crashing the page.
Instrument agents built on Anthropic's Claude Agent SDK. Sessions, tool calls, and results flow straight into Prefactor alongside your LangChain, Vercel AI SDK, and OpenClaw agents.
The TypeScript SDK now ships a Claude Agent SDK integration alongside the existing LangChain, Vercel AI SDK, and OpenClaw support. Both SDKs also report their own version with every connection, so the platform knows exactly which SDK build produced each span.
Define custom span schemas for individual tools in your LangChain and Vercel AI SDK agents. Tool-specific span types replace generic "tool call" events, giving you observability that matches your agent's actual architecture.
Custom span schemas per tool in Python and TypeScript SDKs. Dynamic, tool-specific span types for LangChain agents. Vercel AI SDK support with matching schema definitions. Spans correctly reflect multi-tool agent workflows.
One-command authentication with `prefactor login`. Pre-built binaries for Windows, macOS, and Linux (x64 + ARM), with canary and stable release channels.
Browser-based auth flow with secure token storage. Automated CI builds for all major platforms. Canary channel for bleeding-edge users. No more manual token management or env variable setup.
Subscribe to agent instance updates in real time. WebSocket API includes graceful instance termination handling and live status streaming for running agents.
WebSocket subscriptions for agent instance events. Graceful termination handling for running instances. Real-time status updates without polling.
New `data_risk` field in span type schemas surfaces agent risk signals directly in the Prefactor dashboard. Monitor which tools are handling sensitive data at a glance.
Risk visibility per span type in the UI. Surface data handling patterns across agent workflows. Complements existing policy engine enforcement.
UUID-based idempotency keys across Python and TypeScript SDKs. Every span and agent operation is retry-safe with server-side validation, ensuring data integrity in production workloads.
Auto-generated UUID idempotency keys on all operations. Server-side key validation (64-char limit enforced). Prevents duplicate data on network retries. Critical for production agents with real-world side effects.
Agent instances from OpenClaw now render in a human-readable conversation format. Understand agent reasoning and tool usage patterns at a glance instead of parsing raw event logs.
Conversation-style rendering of agent instances. Clear visibility into reasoning chains and tool calls. Designed for non-technical stakeholders reviewing agent behaviour.
TypeDoc-generated API documentation for Core, AI SDK, LangChain, and OpenClaw packages. New guides for instrumenting existing agents and building provider adapters. Setup scripts now work on macOS.
Comprehensive API docs across all major packages. Step-by-step guides for agent instrumentation. Provider adapter development guide. Cross-platform setup (macOS + Linux).
Setup scripts now work on macOS. OpenAPI spec generation added to CI. SDK core init refactored to a provider-based client API with improved shutdown semantics.
Cross-platform setup (macOS + Linux). OpenAPI spec auto-generated on every CI run for accurate API documentation. SDK init moved to a provider pattern — cleaner configuration and deterministic shutdown.
Redesigned onboarding with integration cards and guided setup panel. OpenClaw agent instances now render as human-readable conversations.
Getting started page rebuilt with framework-specific integration cards and an interactive setup panel. OpenClaw conversation view renders agent instances in a chat-style format — reasoning chains, tool calls, and results displayed clearly for non-technical reviewers.
TypeDoc-generated API docs for all major packages. New P2 CLI tool for managing agents from the terminal. Skill guides for instrumentation and provider adapters.
Comprehensive TypeDoc API documentation across Core, AI SDK, LangChain, and OpenClaw packages. P2 CLI tool for terminal-based agent management. Clarified SDK import guidance. Skill docs for instrumenting existing agents.
Major version update to the Python SDK with an improved API surface. Aligns with the TypeScript SDK's architecture for consistent cross-language developer experience.
Updated API surface matching the TypeScript SDK patterns. Improved init and shutdown semantics. Better error messages and type hints.
First-party OpenClaw plugin for instrumenting Vercel AI SDK agents. Drop-in integration with automatic span collection and skill guides for setup.
OpenClaw plugin automatically instruments Vercel AI SDK agents. Collects spans, tool calls, and completions without manual instrumentation. Includes skill guides for common integration patterns.
Next-generation TypeScript SDK architecture with a direct transport layer. Removes intermediary abstractions for lower latency and simpler debugging.
Direct transport architecture eliminates buffering layers between SDK and API. Simplified error propagation. Cleaner shutdown semantics.
No updates in this category yet.
Prefactor helps teams observe, evaluate, and improve their AI agents in production, across every framework and provider.