Prefactor
Also known as: prefactor.ai, prefactor.tech
Records every step AI agents take in production, ties each run to its agent version and environment, scores its data risk under profiles you set, and stores your own evaluation results per run, with SDKs and APIs across frameworks.
Prefactor records and scores what AI agents do in production. Its SDKs and OpenTelemetry support send each step an agent takes (every LLM call, tool call, message turn or custom business step) to Prefactor, which ties each run to the agent version and environment that produced it and keeps the chain as an audit trail. Teams declare an activity schema per agent, deploy versions across dev, staging and production, and watch runs live.
Risk profiles score each run from the capabilities its steps declare, weighting data categories such as standard PII, sensitive data and GDPR special categories against thresholds the team sets; the docs say these scores are labels for human review and do not block a run on their own. Teams can attach the results of their own evaluations to each run through quality schemas, see run health (success rate, duration, failures) per agent, and terminate an active run by hand. The marketing site and pricing page go further, describing real-time scoring, eval-gated promotion and hold, approve or block enforcement, which the technical docs do not yet document.
Prefactor fits AI platform teams that want a run-level record of every agent across environments. It does not build, host or orchestrate agents, ground them in knowledge or give them memory, and access within an account is not split by role. It runs as a managed cloud service, with self-hosting listed on the Enterprise plan, and publishes usage-based pricing from a free tier.
Vendor details
Canonical URL
https://prefactor.tech
Category
Agent infrastructure
Subcategory
Agent run recording, risk scoring and evaluation intake
Funding status
Independent. Pre-seed round in June 2026 with Antler, Black Nova Venture Capital and Func Ventures, per Crunchbase; amount not disclosed.
Company status
independent
Use cases & customers
Primary use cases
Target customers
Deployment options
Integrations
Python and TypeScript SDKs, framework middleware and OpenTelemetry bring each step an agent takes into Prefactor as spans, for agents built on LangChain, CrewAI, Anthropic, OpenAI and other stacks. An HTTP API, a WebSocket stream of run updates and a CLI cover the platform itself.
In practice
Your agents run on three frameworks across dev, staging and production. Prefactor records every step of every run and ties it to the agent version that produced it.
Compliance wants to know which agent runs touched special-category personal data. A risk profile weights those categories, and each run carries a score and level for review.
Your team grades agent outputs with its own eval suite. Results attach to each run through a quality schema, so scores sit next to the run they describe.
Sources & related URLs
Agentic Index coverage score
4.5 / 14 capabilities · 32%
| Integrations & Tool Calling | Partial |
|---|---|
|
Agents built on LangChain, CrewAI, Anthropic, OpenAI and other stacks are instrumented through Prefactor's SDKs, framework middleware and OpenTelemetry support, so their steps flow in as spans. These bring telemetry in; no connector lets an agent take authenticated action in an outside system through Prefactor. SourcePrefactor, docs.prefactor.ai llms-full.txt (SDK overview, instrumentation strategy) and prefactor.tech llms-full.txtread 2026-09-25 |
|
| Workflow Orchestration | Not documented |
|
Steps, sequencing and handoffs belong to the agent's own framework: Prefactor records and scores what agents do and does not run their work, and the docs state Prefactor never ends a run on its own schedule. Agent versions and deployments across environments are release records, not a workflow model. SourcePrefactor, docs.prefactor.ai llms-full.txt (Instance, Deployments and Versions tabs)read 2026-09-25 |
|
| Knowledge Grounding & RAG | Not documented |
|
Grounding sits outside the product: Prefactor records and scores agent runs and indexes none of the customer's documents for an agent to ground its answers on, so there is no retrieval structure over the customer's corpus. SourcePrefactor, docs.prefactor.ai llms-full.txtread 2026-09-25 |
|
| Human Oversight & Guardrails | Partial |
|
The documented oversight control is a manual one: while a run is active, an operator can terminate it from the agent instance page with a stated reason, and the agent's integration winds the run down. Risk profiles classify each run from the capabilities its spans declare, but the docs state that crossing a threshold does not automatically block or terminate a run: the classification is a label for human review and enforcement remains with the customer's team. The pricing page claims real time hold, approve or block, which that statement contradicts. No approval step or guardrail sits beside the stop control. SourcePrefactor, docs.prefactor.ai llms-full.txt (Agent instance page, Risk tab, Risk profile) and prefactor.tech/pricingread 2026-09-25 |
|
| Security, Identity & Governance | Partial |
|
Access controls are thin but present: accounts can sign in through single sign on with the customer's identity provider (listed on the Enterprise plan), and API tokens are created per account and revoked when their creator is removed. The docs state that all members of an account share the same level of access, with no role based permission distinctions. No attestation is published: the compliance pages describe how Prefactor's records serve as evidence in a customer's own SOC 2, ISO 27001 or EU AI Act review, which is not Prefactor's own certification. SourcePrefactor, docs.prefactor.ai llms-full.txt (Team tab, API tokens tab) and prefactor.tech/pricing and llms-full.txtread 2026-09-25 |
|
| Observability & Auditability | Full |
|
Each agent run is recorded as an instance with its full span timeline (LLM calls, tool calls, message turns and custom business steps), tied to the agent version and activity schema version that produced it and, where a profile is assigned, the run's risk classification; the docs call this chain the audit trail. The Activity tab and a WebSocket stream show runs and updates live, sensitive fields can be encoded before they leave the agent, and data retention runs from 7 days on the free plan to 12 months on the upper plans. SourcePrefactor, docs.prefactor.ai llms-full.txt (The audit trail, Agent instance page, Activity tab, WebSocket API, Sensitive encoding) and prefactor.tech/pricingread 2026-09-25 |
|
| Memory & State Persistence | Not documented |
|
Run records, risk scores and quality results are kept about agents, not as memory for them; the agent never reads them as context to decide. No memory layer is documented. SourcePrefactor, docs.prefactor.ai llms-full.txtread 2026-09-25 |
|
| Deployment & Data Residency | Partial |
|
Self hosted deployment appears only as a line on the Enterprise pricing card; the company's own llms-full.txt describes Prefactor as a managed cloud service, and the docs describe no install, region or customer environment option. Dev, staging and production environments are logical environments inside the service. SourcePrefactor, prefactor.tech/pricing and llms-full.txt, and docs.prefactor.ai llms-full.txt (Environments tab)read 2026-09-25 |
|
| Prebuilt Agents / Templates / Packs | Not documented |
|
Prefactor ships no ready made agents, workflows or templates for a buyer to adopt. Risk profiles can start from a preset that fills in weights, which is a settings preset, not a packaged asset. SourcePrefactor, docs.prefactor.ai llms-full.txt (Risk page)read 2026-09-25 |
|
| Triggers & Channel Coverage | Not documented |
|
Runs start in the customer's own code: the agent's integration registers each run when it starts, and the WebSocket stream sends updates about runs outward. Prefactor does not start agents, and no schedule, webhook or event of its own wakes one. SourcePrefactor, docs.prefactor.ai llms-full.txt (Instance, Stream agent instance updates)read 2026-09-25 |
|
| Model Flexibility & Routing | Not documented |
|
Model choice stays with the agent's own framework: Prefactor records the model calls an agent makes but does not choose or route models. The pricing page lists optional bring your own LLM evals, but the docs place evaluation outside Prefactor and document no provider selection, so no customer model choice inside the product is shown. SourcePrefactor, docs.prefactor.ai llms-full.txt and prefactor.tech/pricingread 2026-09-25 |
|
| APIs / SDKs / MCP Extensibility | Full |
|
An HTTP API and a WebSocket API cover the platform (with rate limits, sensitive field encoding and live instance streaming), alongside a CLI for environments and agents, agent skills, and Python and TypeScript SDKs with configuration, schema, rate limit and termination handling. SourcePrefactor, docs.prefactor.ai llms-full.txt (HTTP API, WebSocket API, Prefactor CLI, SDK overview, Python SDK)read 2026-09-25 |
|
| Testing, Debugging & Optimization | Partial |
|
The customer's evaluations get a structured home: an agent's activity schema declares named quality schemas, runs are marked as live, eval or smoke test, and the customer's evaluation process submits its result after a run, shown on the run's Quality tab (with an optional summary template) and recorded as quality spans. The docs state that Prefactor does not produce these evaluations; the eval suite, grading model or human review happens outside it. The agent's own Quality tab shows run health over the last day (success rate, typical and worst duration, failures). Storing and trending the customer's own scores is not an evaluation harness of the vendor's own. SourcePrefactor, docs.prefactor.ai llms-full.txt (Agent instance Quality tab, Agent Quality tab, Instance, Quality and performance) and prefactor.tech/pricingread 2026-09-25 |
|
| Browser / Computer-use | Not documented |
|
Prefactor records and scores agent runs and does not operate a browser or a computer; no browser or computer use capability is documented. SourcePrefactor, docs.prefactor.ai llms-full.txtread 2026-09-25 |
|
The Agentic Index coverage score grades every vendor Full, Partial or Not documented against the same 14 buyer facing capabilities, from public evidence only. Each capability links to how all vendors in the index score on it. How this evidence is graded
Pricing
Dev free (5,000 spans) · Startup $49/mo · Scaleup $199/mo · plus per-span overage
spans (one step an agent takes: an LLM call, tool call, message turn or custom step)
Included quota
5,000 spans a month on Dev, 15,000 on Startup, 100,000 on Scaleup
What is public
All plan prices, span allowances, overage rates, agent limits and retention periods are public; Enterprise is quoted.
Billing mechanics
Every plan carries the full platform; plans differ by included spans, agents and retention, and spans past the allowance are billed per span. Annual billing saves up to 20%.
Cost watchouts
Spans past the plan allowance are billed per span, and every LLM call, tool call and message turn counts as one, so busy agents add up; scores, risk checks and interventions do not create spans.
Variable cost rationale
Cost grows with spans past the allowance at a published per-span rate, so spend tracks agent activity but is predictable from the calculator on the pricing page.
Additional watchouts
Retention is 7 days on the free plan and 3 months on Startup, so history for audits needs Scaleup or Enterprise.
Overage / add-ons
$0.0025 a span on Startup; $2.50 per 1,000 spans on Scaleup monthly or $2.00 on annual, up to 4M a month
Sales call required
Mixed (some tiers require a call)
Free / trial
Dev plan free with 5,000 spans a month, up to 3 agents and 7-day retention, no credit card
Lowest paid plan
Startup, $49 a month or $499 a year, 15,000 spans included
Key ambiguities
Enterprise rates, and whether the self-hosted Enterprise option carries its own pricing.
Missing data
Enterprise pricing.