Resources

AI Agent Glossary

The language of AI agent identity, permissions, audit, and governance, in plain English. Whether you are an engineer wiring up an SDK or a compliance lead asking what an agent can prove, start here.

64 terms

A2A (Agent-to-Agent): An emerging class of protocols for agents to communicate and delegate to one another. Vorim's signed identity and attenuated delegation are designed to provide the trust layer beneath such interactions.
ACP (Agentic Commerce Protocol): A protocol for AI agents to complete payments and checkouts on a user's behalf, such as Stripe's Agentic Commerce Protocol. Vorim authorizes the acting agent and signs the payment lifecycle, so an agent transaction carries a verifiable record of which agent paid and whether it was allowed to.
Agent Card: In the A2A protocol, a machine-readable description an agent publishes about itself: who it is, what it can do, and how to reach it. Vorim can extend an Agent Card with a cryptographic identity and a live trust score, so a counterparty can verify an agent before interacting with it.
Agent Identity: A unique, verifiable identifier for a single AI agent, anchored to a cryptographic keypair rather than a shared API key. It lets every action be attributed to a specific agent that can be verified and, if needed, revoked.
Agent Memory: Storage that lets an agent retain context across steps or sessions, beyond a single context window. Short-term memory holds the current task; long-term memory holds facts, preferences, and past outcomes. Shared memory across multiple agents is powerful and risky, which is why governed memory attributes and signs every write.
Agentic Workflow: A process where one or more AI agents carry out a multi-step task by planning, calling tools, and reacting to results, rather than following a fixed script. The non-determinism is what makes identity, permissions, and audit hard.
AI Agent: An autonomous software system, usually powered by a large language model, that can take actions on its own: calling tools, querying APIs, reading and writing data, and making decisions without a human in the loop for each step. Unlike a chatbot that only replies, an agent acts.
Attenuated Delegation: Delegation where each hop can only narrow permissions, never widen them, and the narrowing is cryptographically enforced. This lets a chain of agents pass authority along multiple hops while staying provably within bounds.
Audit Coverage: The share of an agent's actions that are actually captured in the audit trail. Gaps in coverage are where incidents hide, so the goal is every action recorded, signed, and exportable.
Audit Trail: A chronological record of every action an agent took: what it did, when, on what resource, and with what result. The basis for incident response, compliance, and forensic review.
Canonicalization: Converting data into a single, deterministic byte form before hashing or signing, so the same logical content always produces the same signature. Vorim uses JSON Canonicalization Scheme (RFC 8785) for this.
Chain of Custody: A documented, verifiable history showing that evidence has not been altered from creation to review. For agent actions, a signed, tamper-evident audit trail is what establishes it.
Compliance Export: A signed bundle of audit events, with a manifest of hashes, packaged for a regulator or auditor. Vorim exports these in JSON, CSV, or PDF so the recipient can verify them offline.
Context Window: The maximum amount of text, measured in tokens, a model can consider at once, covering the system prompt, conversation, retrieved data, and tool results. Once work exceeds it, older context must be summarized or dropped, which is why long-running agents need external memory.
Credential Delegation: Letting an agent use an external OAuth credential (Google, GitHub, Slack) through a scoped, revocable grant, so the agent can act against that service without the raw refresh token ever leaving the vault.
Delegation: When one agent grants a subset of its permissions to another agent so it can act on its behalf. Safe delegation requires that the delegate can never gain more than the delegator had.
did:key: A W3C Decentralized Identifier method that encodes a public key directly into the identifier itself, so an identity can be created and verified with no registry or lookup. Vorim uses did:key for ephemeral agents, which self-issue an identity on creation.
Digital Signature: A value produced with a private key that anyone can verify with the matching public key. It proves both who created a piece of data and that it has not changed since.
Ed25519: A modern public-key signature algorithm that is fast, compact, and resistant to common implementation mistakes. Vorim uses it for agent keypairs and signatures. It is the same algorithm behind SSH and Signal.
Ephemeral Agent: A short-lived agent that bootstraps its own identity on creation, in Vorim using the W3C did:key format, and auto-expires after a set time-to-live with no manual cleanup. Useful for one-off tasks, CI/CD runs, and tests. It still gets full permission checks and a signed audit trail while it lives.
Escalation Queue: A holding area where high-risk agent actions wait for a human operator to approve or deny them. The agent pauses until a verdict is given, then proceeds or stops accordingly.
EU AI Act: The European Union's regulation governing AI systems by risk level. It introduces documentation, transparency, and record-keeping obligations, phased in over several years; under the 2026 Digital Omnibus the high-risk (Annex III) obligations were deferred to December 2027.
Fail-Open vs Fail-Closed: How a system behaves when the decision service is unreachable. Fail-open lets the action proceed so agents keep working; fail-closed blocks anything not explicitly allowed. Vorim makes this configurable per organization.
Fingerprint: A short, fixed-length hash (Vorim uses SHA-256) derived from an agent's public key. It acts as a compact, human-comparable identifier for the agent's identity.
Guardrails: Rules and checks that constrain what an agent is allowed to do or say, applied before or after a model call. Prompt-level guardrails can be bypassed by a clever input; enforced permission checks and runtime policy are the guardrails that hold because they sit outside the model.
Hash Chain: A sequence of records where each one includes the hash of the previous one. Removing or changing any single record breaks the chain, which makes silent deletion of an audit event detectable.
Human-in-the-Loop (HITL): A control where a high-risk action pauses for a person to approve, reject, or edit it before it runs, rather than the agent acting fully autonomously. In Vorim, a runtime decision can route to a named human approver whose approval is itself signed into the audit trail.
IETF Internet-Draft: A working document submitted to the Internet Engineering Task Force, the standards body behind much of the internet. It is the first step toward a recognized, interoperable standard.
Keypair: A matched pair of cryptographic keys: a private key the agent keeps secret and uses to sign, and a public key anyone can use to verify those signatures. Vorim issues a cryptographic identity to every agent on registration.
Kill Switch: The ability to immediately stop an agent, or a class of actions, in production. Useful when an agent starts behaving unexpectedly and you need to halt it without redeploying.
Least Privilege: The principle of granting an agent only the permissions it needs for its job, and nothing more. It limits the blast radius if an agent is compromised or misbehaves.
MCP (Model Context Protocol): An open protocol for connecting AI models and agents to tools and data sources. Vorim ships an MCP server so agents can register, check permissions, and log actions through natural-language tool calls.
Multi-Agent System: An architecture where several specialized agents collaborate, often delegating subtasks to one another. Each agent should have its own identity and scoped permissions so you can tell which agent did what.
Non-Human Identity (NHI): Any identity that is not a person: service accounts, machines, workloads, and now AI agents. In large enterprises non-human identities already far outnumber human ones, and agents are the fastest-growing category.
Non-Repudiation: A guarantee that the party who took an action cannot credibly deny taking it. Per-event signing provides non-repudiation: the signature could only have come from that agent's private key.
OAuth 2.0: The standard framework for delegated authorization on the web. It handles two-hop access well but does not, on its own, provide cryptographic per-hop attenuation across longer agent delegation chains.
Open Protocol: A specification published openly so any party can implement, interoperate with, and verify it, rather than being locked to one vendor. Open protocols are what let identity and audit travel across organizations.
Per-Event Signing at Source: Signing each audit event with the agent's key at the moment it is produced, rather than trusting a central log later. It is what lets a third party verify what an agent did without trusting the platform that stored it.
Permission Check: A verification, made before an action, that an agent holds the required scope for it. Vorim performs these server-side with sub-5ms latency using a Redis cache.
Portable Identity: An agent identity that can be verified across organizations and identity providers, not just inside the system that issued it. Portability is what lets a counterparty trust an agent they did not create.
Pre-Action Decision: A verdict issued before an agent performs an action: allow it, deny it, escalate it to a human, or return a modified payload. It moves governance from after-the-fact to in-the-moment.
Private Key: The secret half of a keypair, used to sign. Vorim returns an agent's private key once at registration and never stores it, so only the agent can produce its signatures.
Prompt Injection: An attack where hostile instructions are hidden in content an agent reads (a web page, an email, a document) to trick it into ignoring its real instructions and taking unintended actions. A key reason agents need permission checks before they act, not just a good prompt.
Public Key: The shareable half of a keypair. It is used to verify signatures and confirm identity, and can be distributed freely without compromising security.
ReAct: A widely used agent pattern, short for "Reason + Act," where the model alternates between thinking through a step and taking an action (a tool call), then feeds the result back into its reasoning. Most tool-using agents follow some variant of this loop.
Replayable Evidence: Recording enough context (input hash, model name and version, tool catalog, system prompt fingerprint) that an agent's decision can be reconstructed and examined after the fact, not just logged as having happened.
Retrieval-Augmented Generation (RAG): A technique where an agent retrieves relevant documents or data at query time and passes them to the model as context, so answers are grounded in a specific knowledge source rather than the model's training data alone.
Revocation: Permanently invalidating an agent's identity or a specific permission so it can no longer act. Effective revocation must propagate quickly and be detectable by anyone who relied on that agent.
Runtime Control: Checking and governing an agent's action before it runs, in real time, rather than only logging it afterward. Vorim returns a decision (allow, deny, or escalate) for each sensitive action against live policy.
Scope: A named permission that defines a category of action an agent is allowed to take. Vorim uses seven: read, write, execute, transact, communicate, delegate, and elevate. Scopes are granted independently, not inherited.
Segregation of Duties (SoD): A control that stops a single agent from performing both halves of a sensitive operation, for example creating a payment and also approving it. Enforcing it across agents prevents one compromised or over-privileged agent from completing a risky task alone.
SHA-256: A widely used hash function that turns any input into a fixed 256-bit fingerprint. Vorim uses it for identity fingerprints, audit content hashes, and hash chaining.
Shadow AI: AI tools and agents used inside an organization without the knowledge or approval of security and compliance teams. A governance blind spot, and a growing driver of demand for agent identity.
Signed Audit Trail: An audit trail where each event is cryptographically signed at the source, so anyone can verify it has not been altered. This is the difference between a log you have to trust and a record you can prove.
SOC 2: An auditing standard covering how a service organization handles security, availability, and confidentiality. SOC 2 reviews increasingly ask how AI agent actions are logged and proven.
System Prompt: The instructions that define an agent's role and behavior, set before any user input. Recording a fingerprint of the system prompt is part of replayable evidence: it proves what the agent was told to do.
Tamper-Evident: A property of a record where any modification, deletion, or reordering becomes detectable. Achieved by hashing each event and chaining the hashes so a break is mathematically visible.
Time-Bounded Permission: A grant that is only valid within a defined window or until an expiry. It lets you issue access that automatically lapses instead of lingering as standing privilege.
Token Budget: A cap on how many model tokens an agent or workflow may spend over a rolling window. Vorim meters spend against the budget in real time and can deny or escalate an action before a runaway agent blows past it, so cost overruns are stopped at the decision point rather than discovered on the invoice.
Tool Call: When an agent invokes an external function, API, or capability (search the web, send an email, run a query). Tool calls are the moments where an agent actually affects the outside world, which is exactly where governance matters.
Tool Catalog: The set of tools an agent had available at the time it made a decision. Recording a hash of the tool catalog lets an auditor later reconstruct exactly what the agent could have done.
Trust Badge: An embeddable, publicly verifiable visual (an SVG) that displays an agent's current trust score, so partners and customers can see an agent's standing without taking your word for it.
Trust Score: A continuously updated number (Vorim uses 0 to 100) summarizing how reliably an agent has behaved, based on factors like status, age, success rate, denial frequency, and how broad its permissions are.
VAIP: The Vorim Agent Identity Protocol: an open specification, filed as an IETF Internet-Draft, for agent identity, signed audit, and attenuated delegation. Being open means anyone can implement and verify it independently.