Delegated authority management for AI agents.
Veracta checks authority, evidence, reliance and accountability before an AI agent acts — returning allow, escalate or block, with a full audit trail. Not runtime monitoring. Not post-hoc review. A pre-action decision layer.
- Records sources, revisions and policy matches
- Captures AI assumptions and confidence
- Checks authority before execution
- Creates an immutable audit trail
Before your AI acts, ask Veracta.
An AI agent generates a BoM from drawing v2.3, spec rev A and approved parts library v4. Veracta records every source, assumption and confidence score before release — and escalates when two items fall below the confidence threshold.
AI agents are moving from advice to action.
AI agents can now send emails, update systems, approve work, access data and trigger workflows. But most businesses do not have a simple way to decide what those agents are allowed to do, when approval is required and who owns the outcome if something goes wrong.
Pre-action authority, not runtime observation.
Veracta is not a monitoring, tracing or forensic tool that inspects what software did after the fact. It is a delegated authority management layer that decides — before an AI agent acts — whether the action falls inside human-approved authority. Low-risk admin can happen automatically and be logged. High-risk actions involving money, reputation, sensitive data or external commitments escalate for approval. Actions outside authority are blocked.
Evidence before authority.
AI agents can produce work that sounds confident, but businesses need to know what evidence was used before that work becomes action. Veracta records the sources, assumptions, confidence, policies and approval route behind every AI action.
Trust breaks when AI sounds certain but cannot prove itself.
One API call between intent and action.
Every action flows through the same sequence: the agent asks, Veracta decides, the outcome is audited — all before a single side effect hits your systems.
Agent requests an action
The AI agent calls POST /v1/check-authority with the intended action, target, amount or scope, and any relevant context.
Veracta evaluates delegated authority
Veracta matches the request against active policies, delegated scopes, revisions and reliance sources — then returns exactly one decision.
Agent executes the action
Signed audit entry with policy match and reliance sources
Action paused, routed to a named human owner
Audit entry captures the approver, context and response time
Action refused before it executes
Audit entry records the failing policy and reason for refusal
Outcome is recorded before the agent executes
Veracta writes an immutable audit entry — with a signed audit_id, the policy that fired, the reliance sources, and a human-readable reason — before the agent is told it may proceed. If the decision is BLOCK or ESCALATE, no side effect ever runs.
Authority depends on context.
Veracta does not need to understand the whole live state of a business. It captures the relevant decision state around the specific action an AI agent wants to take.
State-dependent, proportional, revocable and auditable.
Authority should not be a permanent label. It should expand or contract based on the action, context, risk and evidence available at the moment an AI agent tries to act.
Add authority checks to your AI agent in one API call.
POST /v1/check-authority
{
"agent_id": "finance_agent_01",
"organisation_slug": "veracta-demo",
"action_type": "approve_invoice",
"action_summary": "Approve invoice from ABC Supplies for £1,250",
"value": 1250,
"currency": "GBP",
"risk_level": "medium",
"confidence": 0.82,
"reversibility": "medium",
"external_commitment": true,
"data_sensitivity": "low",
"recipient_domain": "abc-supplies.co.uk",
"domain_status": "approved",
"human_owner": "mike@gamesterinc.com"
}{
"decision": "ESCALATE",
"reason": "This action involves money, creates an external commitment and exceeds the approved automatic authority limit.",
"next_step": "request_human_approval",
"audit_id": "audit_123",
"authority_status": "outside_automatic_authority"
}import requests
decision = requests.post(
"https://api.veracta.net/v1/check-authority",
headers={
"Authorization": "Bearer va_live_...",
"Content-Type": "application/json",
},
json={
"agent_id": "finance_agent_01",
"organisation_slug": "veracta-demo",
"action_type": "approve_invoice",
"action_summary": "Approve invoice from ABC Supplies for £1,250",
"value": 1250,
"currency": "GBP",
"risk_level": "medium",
"confidence": 0.82,
"reversibility": "medium",
"external_commitment": True,
"data_sensitivity": "low",
"recipient_domain": "abc-supplies.co.uk",
"domain_status": "approved",
"human_owner": "mike@gamesterinc.com",
},
).json()
print(decision["decision"]) # ALLOW, ESCALATE, or BLOCK
print(decision["reason"])
print(decision["audit_id"]) # immutable audit trail
if decision["decision"] == "ALLOW":
approve_invoice()
elif decision["decision"] == "ESCALATE":
request_human_approval(decision["next_step"])
else:
log_blocked_action(decision["audit_id"])Copy the snippet, swap in your API key, and run it. Veracta returns ALLOW, ESCALATE, or BLOCK before the agent acts — with an audit ID you can rely on.
See how action type and risk level map to a decision.
Pick an action and a risk level. Veracta returns one of ALLOW, ESCALATE, or BLOCK with the exact policy that fired and a readable audit reason.
{
"decision": "BLOCK",
"action": "payment.transfer",
"risk": "high",
"policy": "policy:high_stakes.high_risk",
"audit_id": "aud_5eab127cbh",
"reason": "payment.transfer at high risk is outside delegated authority. Blocked pending owner re-delegation with a scoped, time-bound approval."
}Wherever AI agents take real actions.
AI can create the BoM. Veracta decides whether it is trusted enough to release.
An AI agent generates a project-specific Bill of Materials from drawings and specifications. Before it is released, Veracta checks the evidence behind it.
Assume automation. Prove trust.
A record of what the AI relied on — before it acts.
Veracta records the evidence behind AI action before execution. It captures what data, documents, policies, revisions, assumptions and authority rules the AI relied on when proposing an action.
As AI agents move faster across systems, businesses need to prove what information was relied upon, where it came from, whether it was approved, what state it was in, and who authorised the action. Veracta creates a record of reliance for every AI authority check.
Record of Reliance fields
Example — Bill of Materials
- AI-generated BoM
- Source drawings used
- Drawing revision
- Customer specification revision
- Approved parts library version
- Assumptions made
- Low-confidence items
- Exceptions raised
- Human approval route
- Final release decision
AI creates the work. Veracta proves whether it can be trusted, authorised and released.
Decide before the action. Don't just watch it afterwards.
Runtime observation and forensic monitoring products record what AI systems did so teams can detect anomalies, investigate incidents and improve safety after the fact. Veracta stops risky actions before they happen by checking delegated authority at the point of decision.
Veracta complements observability and monitoring tools. It adds the delegated authority layer they are not designed to provide.
Similar name. Different layer of the stack.
People land here searching for veracta.io, an AI runtime monitoring product. Veracta.net is a different company solving a different problem: delegated authority before the action, not observation after it.
- When it runs
- After the AI acts
- Question it answers
- What did the model just do?
- What it inspects
- Prompts, outputs, traces, session replays
- Outcome
- Detect drift, evaluate quality, investigate incidents
- Built for
- ML / AI observability teams
- Passive: reads what the model produced
- Can't stop an action from happening
- Answers post-hoc questions about behavior
- When it runs
- Before the AI acts
- Question it answers
- Is this specific action allowed right now?
- What it inspects
- Delegated scopes, policies, sources, revisions
- Outcome
- Return ALLOW, ESCALATE or BLOCK with a signed audit_id
- Built for
- Platform, security and agent-engineering teams
- Active: authorizes or refuses the action itself
- Blocks unsafe actions before they execute
- Answers the accountability question up front
If you're looking for AI runtime monitoring, veracta.io is the right destination. If you need an API that decides whether an AI agent is authorized to act — and leaves a record of that decision — you're in the right place.
Not another chatbot. Not another compliance dashboard.
Veracta is an action authority layer. It does not replace IAM, security or governance platforms. It gives builders a simple API to check authority at the moment an AI agent tries to act.
IAM
Controls identity and access.
AI governance
Manages policies, compliance and evidence.
Veracta
Controls action authority before execution.
Builders integrate. Businesses control.
Agent builders integrate Veracta, but businesses control the authority boundaries. Every escalation routes to a named human owner.
Agent Developer
The developer or agency building the AI agent. They integrate the Veracta API into their agent code.
Company / End Customer
The business using the AI agent. They own the authority rules, human approvals, policies and audit trail.
Human Approver
The named person inside the company who approves, rejects or requests changes when an AI action is escalated.
Start free. Upgrade when your agents start acting.
Start free. Add authority checks to your agent in minutes. Upgrade when your agents start acting in real workflows.
Growth
For SMEs and active agent workflows
Includes 100,000 authority checks/month
Get startedAgency
For agencies managing multiple client workspaces
Multiple client workspaces and higher usage
Get startedEnterprise
For larger companies needing SSO, compliance support, custom limits, data controls and support
SSO, compliance and data controls
Contact usCompany-owned account
The company owns the Veracta workspace and pays directly. Developers are invited as integrators.
Developer / agency account
The developer or agency pays for Veracta and includes it in their agent build or monthly support package.
Veracta checks authority, evidence, reliance and accountability before AI action.
Developers use Veracta to make their AI agents safer and easier to sell.
Companies use Veracta to control what AI agents are allowed to do before they act.
Common questions.
What is Veracta?
Veracta is a delegated authority management API for AI agents. Before an agent sends money, updates a system, commits externally or triggers a real-world action, Veracta returns allow, escalate or block — with the evidence, policy and reliance behind the decision.
Authority before action vs runtime observation after the fact
Veracta decides whether an AI agent is allowed to act before the action runs. Runtime observation and forensic monitoring products watch what software did after the fact. Veracta does not monitor traffic, trace calls or provide post-hoc forensics. It returns a decision at the point of action, then records the decision and evidence for audit.
Who is Veracta for?
Agent developers and agencies integrate Veracta to make their AI agents safer and easier to sell. Companies use Veracta to control what AI agents are allowed to do and to keep a full audit trail of every authority decision.
How does it work?
Your agent sends a single API call describing the action it wants to take. Veracta evaluates the decision state — action type, value, risk, evidence, confidence, policy and human authority — then returns allow, escalate or block, plus an audit ID.
What does Veracta cover?
- Authority limits and policy checks before an action
- Allow / escalate / block decisions
- Evidence, source revision and assumption capture
- Confidence scoring and low-confidence escalation
- Human approval routing and named ownership
- Immutable audit trail of every authority decision
- Integration into agent code via a single API call
What does Veracta not cover?
- Real-time traffic monitoring or log streaming
- Post-execution forensics or incident reconstruction
- LLM prompt tracing or token-level observability
- General model evaluation or benchmarking
- Identity and access management (IAM) replacement
Building AI agents? Add authority before action.
Veracta v0.1 is the first live API. Join early access to add allow / escalate / block authority checks to your agents.
Before your AI acts, ask Veracta.