AI agents act on their own, but they still need a person's permission and a clear paper trail. The HASP Agent SDK gives every agent its own identity, the exact permissions a person granted it, and a tamper-evident log of every action it took. Works with your existing agent framework — or with the open Agent-to-Agent (A2A) protocol.
Agents get first-class identities — not API keys masquerading as users. Each agent has a scoped delegation token, an audit-chain identity, and a max-delegation-chain depth enforced at the platform layer. Who authorized what, on behalf of whom, is in every audit entry.
Pre-action tool authorization gate
Every tool invocation by an agent passes a pre-action authorization check before execution. The gate evaluates the agent's delegated scope, the tool's policy classification, and org-level policy overrides. Blocked invocations are logged; approved invocations are metered as Agent Actions.
A2A protocol endpoint
HASP exposes a standards-aligned Agent-to-Agent protocol endpoint. External agents — MCP clients, LangChain orchestrators, custom automation — can discover HASP's tool surface, request delegated authorization, and invoke tools through the policy gate without custom integration code.
OAuth 2.1 + RAR delegated authorization
Agent delegation uses OAuth 2.1 with Rich Authorization Requests. Scopes are bounded to what the human or app authorized — an agent can never escalate beyond the rights it was delegated. Token issuance and revocation are audit-chain events.
Agent Actions meter
Every authorized tool invocation is one Agent Action: policy gate evaluation, audit chain entry, delegation tracking, and integrity-chain compute. See the pricing page for current included allotments and overage rates per tier.
Studio-native agentic workflows
Agentic workflows built in Studio use the same agent identity layer under the hood. Long-running, queued, multi-agent supervised workflows are available on Professional+ via the workflow runtime. Solo tier supports synchronous agent invocations within a single request.
The A2A protocol — one way to connect
The Agent-to-Agent (A2A) protocol is an open standard for how outside agents talk to HASP. It
works the same way as Assistant chat does for a person: the agent proves who it is, what it's
allowed to do, runs through the same PHI and permission checks, and leaves the same
tamper-evident audit record. Same rules, different caller.
Discovery
Agents find available tools through a standard interface. No custom integration work per vendor.
Delegated authorization
A person (or app) grants exactly what an agent may do — and nothing more. Built on OAuth 2.1.
Invocation
Every action passes the same permission and PHI checks before reaching sensitive systems.
Accounting
Every action gets logged with a tamper-evident signature, tied back to the person who authorized it.
Who this is for
Buyers now ask how AI agents fit into your security model. A clear answer — agents have their
own identity, their own permissions, their own audit trail — turns a hard procurement question
into a short one. Reviewers can see that a person and an agent leave the same kind of record,
and that revoking access works the same way for both.
✓
Teams building multi-step healthcare workflows with LangChain or LangGraph.
✓
EHR integrations that run background tasks after a clinician's approval.
✓
Security teams that need a clear, replayable record next to every alert.
✓
Partners building on the open MCP standard who still need HIPAA-ready controls.
FAQ
An Agent Action is a single tool invocation by an agent — an AI acting under delegated human authority — that passes HASP's pre-action authorization gate. The meter captures what HASP adds on each tool call: scope evaluation, an entry in the signed audit chain, delegation tracking, and integrity-chain compute. Pure-inference customers (no agent identity) never see an Agent Action charge. The rule of thumb: thinking is metered everywhere AI runs (AI Credits); doing is metered only when an agent invokes a tool (Agent Actions).
HASP's A2A endpoint implements the Agent-to-Agent protocol, allowing external agents to discover HASP's tool surface, request delegated authorization (via OAuth 2.1 + RAR), and invoke tools through the policy gate. The protocol is MCP-compatible — existing MCP clients can connect without modification.
Each time an agent hands work to another agent, that's one link in a delegation chain. HASP caps chains at 10 links on all paid plans (3 on Free Evaluation). The cap is a safety rail against runaway loops, not a pricing lever — Enterprise customers with a legitimate need for deeper chains can raise it by contract. The gateway blocks the call if a chain would exceed the limit.
Yes. External agents connect via the A2A endpoint or the Agent SDK client library. You don't need to use Studio at all — the Agent SDK is a standalone way to build on HASP.
No. A2A only changes how an agent proves who it is. Once authenticated, the request runs through the same PHI handling and permission checks as a request from a person or an app — same rules, same audit record.
Outside agents connect directly. A LangChain agent running in your environment, a partner's orchestrator, or an MCP client all use the same permission and audit system as anything you build inside HASP.
Assistant, Studio, Public API, Agent SDK, and Audit & Trust are different ways to use the
same platform. Pick any page to see how permissions, PHI handling, and audit logging work for
that way of calling in.