Previous PayReality technical work. This page documents an earlier product direction and does not describe our current offering or availability. See what we're working on now.

← Developers

Getting Started

Eight steps from an empty organization to a signed decision on a real agent action.

If you're an existing customer standing up your organization, the eight steps below are the real path. If you're evaluating PayReality and want a real Decision without any of that setup, skip ahead: a sandbox organization, on the same production backend and authority path, is one unauthenticated API call:

get_sandbox.sh
curl -X POST https://api.aisecurewatch.com/v1/sandbox/organizations \
  -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}'

That response includes an API key already scoped to a real, isolated sandbox organization, with one starter Runtime Policy already published, so authorize() works immediately, no Operator Key or dashboard setup required. Sandbox organizations are rate-limited, capped, and not automatically promoted to production. See SDKs for the full sandbox flow.

1

Create an organization

Everything below (agents, policies, evidence) is scoped to one organization. This is done once, from Organization Settings, not the API.

2

Register an agent

Give the agent an identity and a Principal it acts on behalf of. It starts registered, not active.

3

Upload governance, or author it directly

Bring an existing Delegation of Authority document, approval matrix, or signing schedule for the AI Authority Builder to read, or build the graph structure directly where no single document captures it.

4

Generate the Authority Graph

Governance, uploaded or authored, is modeled as a graph: principals, delegates, limits, and role hierarchy, ready for the runtime to query.

5

Publish Runtime Policies

Draft, review, and compile the conditions under which an action is permitted. A policy has to be active before any Intent can be evaluated against it.

6

Connect the Runtime API

Point your agent at the Intent API, or install the SDK (see SDKs for the one-call version of steps 6 and 7 together).

7

Execute your first Intent

Submit a signed action. It's evaluated deterministically against your active Runtime Policies, before the action executes.

8

Receive your Authorization Receipt

The decision (Allow, Deny, or Human Review) comes back immediately, along with the signed evidence record for it.

Steps 2, 6, and 7, with the SDK

Registering an agent, connecting to the Runtime API, and submitting a signed Intent collapse into a handful of calls once the SDK is handling signing for you:

quickstart.py
from payreality import Agent

# Step 2: register (a sandbox api_key, an organization's own scoped key,
# or the platform Operator Key all work here, see SDKs for which to use)
agent = Agent(bearer_token="pr_live_...")
identity = agent.register(name="AP Automation Agent", principal="Finance Manager")

# Steps 6 + 7: connect and execute an Intent
decision = agent.authorize(
    principal="Finance Manager",
    operation="submit_invoice",
    resource="Vendor Payment",
    resource_data={
        "amount": 8500,
        "currency": "USD",
        "vendor": "Acme Supplies",
    },
)

print(decision.outcome)      # ALLOW, DENY, or HUMAN_REVIEW
print(decision.evidence_id)  # step 8: the signed evidence record for this decision

Steps 1, 3, 4, and 5 (creating the organization, uploading governance, generating the Authority Graph, and publishing Runtime Policies) happen in the platform UI today, not through this SDK call. See Authority Graph and Runtime Policies for what each one actually produces.

Where to go next

For the full request and response shape of step 7, see Runtime API. For what step 8's receipt actually contains, see Authorization Receipts. For the whole path end to end, see Architecture.

Other documentation

ArchitectureThe full path from an agent's signed intent to a decision and its evidence, component by component.Runtime APIThe Intent API: POST /v1/intents, its three possible outcomes, and the request/response lifecycle.AuthenticationThe Operator Key, per-user roles and permissions, per-developer API keys, and agent certificates.Authority GraphDelegated authority, roles, resources, and approval limits, and how governance becomes machine-readable.Runtime PoliciesHow a policy is compiled, versioned, and deployed, and why that differs from the governance document it came from.Authorization ReceiptsWhy logs aren't enough, the receipt lifecycle, and the planned architecture for independent verification.Evidence VerificationSignature verification, evidence export, and audit workflows against the Evidence Portal today.SDKsThe Python SDK, and the language roadmap for Node.js, Go, Java, .NET, and Rust.WebhooksEnterprise events (IntentReceived, DecisionCompleted, ReceiptIssued, and more) with real payloads.Integration ExamplesRotating keys, sending a heartbeat, and retiring an agent, with real SDK code for each.Integration GuidesConnecting Runtime Authority to agent frameworks, model providers, and enterprise systems.Agent RegistrationThe full agent lifecycle: registered, active, suspended, retired, or revoked.API ReferenceEndpoints, schemas, headers, status codes, errors, and versioning.Order WalkthroughOne order, followed end to end: signed intent, declared material fields, capability issuance, rejection on a changed field, and what the receipt path does and doesn't prove.