The four principles AI agents must satisfy.
Every AI agent action in nxtlinq must satisfy four governance criteria before it executes: Attributable, Scoped, Time-bound and Provable. ASTP closes the accountability gap between human intent and machine action at the identity level, not the policy layer.
Every agent action satisfies all four, or it does not execute.
Traditional identity infrastructure was designed for humans logging into systems. It was never designed for autonomous agents acting on behalf of humans, at scale, across systems, without a human in the loop. ASTP was built for exactly that gap.
AI agents execute under service accounts or shared credentials. No individual human is accountable for what the agent does.
Agents with broad IAM permissions can access far more than a task requires, with no enforcement at the action level.
Service accounts and API keys live indefinitely. A compromised credential means unlimited, ongoing exposure.
Logs capture that something happened, not who authorized it, what scope was granted, or whether the action was legitimate.
Every identity issued by nxtID adheres to the ASTP framework, the governing standard that ensures every agentic action is attributable, scoped, time-bound and provable.
Every action traces to a human
The HIT (Human Identity Token) creates an unbreakable cryptographic link between every agentic action and the human principal who delegated authority. There is no anonymous AI execution in nxtlinq.
Least privilege at the agent level
Every AIT (Agent Identity Token) is bound to a specific task, resource set and action type. Agents cannot act outside their explicit authorization, regardless of what the underlying IAM permits.
No persistent credentials for agents
AITs carry explicit expiry enforced at the platform level. Ephemeral Execution Contexts run on micro-runtime TTLs and tokens expire at task completion, removing persistent credential risk.
Cryptographic proof of every action
Every identity event, delegation step and execution outcome is anchored to a decentralized cryptographic ledger. No PII is stored on-chain, only hash-based commitments that enable deterministic audit replay.
ASTP is not a policy layer added after the fact. It is the execution architecture, built into every identity transaction before any agent action is permitted.
The human principal signs in through your existing IAM provider: Okta, Microsoft Entra ID, Ping Identity, or any SAML/OIDC system. nxtlinq does not replace your IAM.
nxtID issues a Human Identity Token linked to the authenticated principal. It becomes the root of accountability for every downstream agent action in the session.
When an agent is invoked, nxtID issues an Agent Identity Token scoped to the task: specific resources, allowed action types, nothing more. The AIT is chained to the parent HIT.
The AIT carries a hard expiry enforced at the platform level. The credential is valid only for the task and is revoked automatically at completion.
The agent reads, writes, calls APIs and invokes tools within the bounds of its AIT. Any out-of-scope attempt is blocked before execution and logged to the audit ledger.
Every governance event (authorization, scope evaluation, execution outcome, token expiry) is hashed and committed to the immutable ledger. No PII on-chain. Full forensic replay on demand.
ASTP is implemented through nxtID's dual-token model. Together the two tokens form the cryptographic foundation for every guarantee the framework provides.
The human anchor of the delegation chain
Issued at authentication via your existing IAM provider: a cryptographically signed record of the human authorizing agentic activity, the root of all attribution under ASTP.
The agent's governed execution credential
Issued to each AI agent at task initiation, linked to the originating HIT, scoped to a specific task and resource set, with a hard expiry enforced at the platform level.
ASTP does not replace your IAM. It governs what happens after authentication, in the layer your IAM cannot see.
| Question | Traditional IAM for AI agents | With ASTP |
|---|---|---|
| AttributionWho is the agent acting for? | Agents run under shared service accounts, with no human attribution | Every agent action traces to a named human principal via the HIT chain |
| ScopeWhat can the agent reach? | IAM roles grant broad permissions, far more than agents need | The AIT scopes each agent to exact task permissions, least privilege enforced |
| CredentialsHow long does access last? | Credentials are long-lived: one compromise means persistent exposure | Micro-runtime TTLs: credentials expire at task completion |
| EvidenceWhat is recorded? | Logs record events, not authorization scope or human delegation | Blockchain-anchored proof of every governance event, not just logs |
| EnforcementWhat stops an out-of-scope action? | No enforcement for what agents do after they authenticate | Policy enforcement before execution: out-of-scope actions are blocked |
| LineageCan sub-agents be traced? | Multi-agent workflows have no lineage; sub-agents are invisible | Sub-agent delegation chains preserved end-to-end across workflows |
| AuditWho authorized this AI action? | Compliance teams cannot answer the question | Auditors get deterministic replay: full forensic reconstruction on demand |
Frameworks that govern AI deployments, such as HIPAA, SOX and FedRAMP, ask for what ASTP delivers: attribution, scope enforcement, time-bounded access and cryptographic proof. When auditors ask, the evidence is already there.
The HIT delegation chain gives cryptographic attribution to the named human principal, meeting the audit requirement for human accountability over AI actions.
The AIT scope is captured at issuance, so auditors see exactly which permissions were granted for each task, not a broad IAM role.
The TTL is recorded and enforced, so access duration is provable from the audit ledger. No persistent credentials to explain to regulators.
Blockchain-anchored cryptographic commitments: tamper-evident, independently verifiable and deterministically replayable for any governance event.
In 15 days: deploy the ASTP framework in your environment with no rip-and-replace. It works with your existing IAM and agent infrastructure from day one. The full patent portfolio is on the compliance page.