Getting Started with Intended in 5 Minutes

Prerequisites

Get the SDKs. The Intended SDKs are published publicly — install @intended-inc/sdk from npm and the Python SDK (intended) from PyPI. A free Intended account gives you an API key to use them. Request platform access or deploy the open source IntendedOps back-office instead.

Runnable. This quickstart uses the published SDKs and their real entry points — createIntendedSdk({ baseUrl, tenantId, apiKey }).authorize() (TypeScript) and IntendedSdk(api_key=, tenant_id=, api_url=).authorize() (Python). See the TypeScript and Python SDK reference for the full surface.

You need a Intended account (free tier is fine) and Node.js 18+ or Python 3.10+ installed. That is it. No Docker, no Kubernetes, no database. The free tier runs in Intended's managed cloud, so there is nothing to deploy.

Step 1: Create Your Account (1 minute)

Go to app.intended.so and create an account. You will need an email address and a password. No credit card required for the free tier.

After email verification, you land on the console dashboard. It will be empty because you have not submitted any intents yet. That changes in the next four minutes.

Step 2: Create an API Key (30 seconds)

In the console, navigate to Settings and then API Keys. Click "Create Key." Give it a name like "quickstart-key" and select the SDLC domain scope (we will use SDLC for this tutorial).

Copy the API key. You will see it only once. Store it somewhere safe. For this tutorial, you will use it as an environment variable.

export INTENDED_API_KEY="intended_live_your_key_here"
export INTENDED_TENANT_ID="your-tenant-id"

Step 3: Install the SDK (30 seconds)

For TypeScript/Node.js:

npm install @intended-inc/sdk

For Python:

pip install intended

Step 4: Submit Your First Intent (2 minutes)

Create a file called quickstart.ts (or quickstart.py) with the following code.

TypeScript

import { createIntendedSdk } from "@intended-inc/sdk";

const sdk = createIntendedSdk({
  apiKey: process.env.INTENDED_API_KEY!,
  tenantId: process.env.INTENDED_TENANT_ID!,
  baseUrl: "https://api.intended.so",
});

async function main() {
  // An AI agent wants to deploy code to staging.
  const decision = await sdk.authorize({
    action: "deploy api-gateway to staging",
    actor: "quickstart-agent",
  });

  console.log("Decision:", decision.decision);   // ALLOW | ESCALATE | DENY
  console.log("Risk Score:", decision.riskScore);
  console.log("Intent ID:", decision.intentId);

  if (decision.allowed) {
    console.log("Token:", decision.token);          // signed authority token (JWT)
  } else if (decision.escalated) {
    console.log("Escalation:", decision.escalationId);
  } else {
    console.log("Denied:", decision.summary ?? decision.rationale.join("; "));
  }
}

main().catch(console.error);

Python

import os
from intended import IntendedSdk

sdk = IntendedSdk(
    api_key=os.environ["INTENDED_API_KEY"],
    tenant_id=os.environ["INTENDED_TENANT_ID"],
    api_url="https://api.intended.so",
)

# An AI agent wants to deploy code to staging.
decision = sdk.authorize(
    "deploy api-gateway to staging",
    actor="quickstart-agent",
)

print(f"Decision: {decision.decision}")   # ALLOW | ESCALATE | DENY
print(f"Risk Score: {decision.risk_score}")
print(f"Intent ID: {decision.intent_id}")

if decision.allowed:
    print(f"Token: {decision.token}")
elif decision.escalated:
    print(f"Escalation: {decision.escalation_id}")
else:
    print(f"Denied: {decision.reason}")

Run it:

# TypeScript
npx tsx quickstart.ts

# Python
python quickstart.py

You should see output like:

Decision: ALLOW
Risk Score: 12
Intent ID: 6f8c2a1e-9d4b-4c7a-bf21-0a1b2c3d4e5f
Token: <signed Ed25519 JWT — verify offline with the public JWKS>

The action was classified as an SDLC deployment to staging. The risk score is low (12 out of 100) because staging deployments are routine. The decision is ALLOW, and a signed authority token (an Ed25519 JWT) was issued — verify it offline with sdk.verifyAuthorityToken(...).

Step 5: See It in the Console (1 minute)

Go back to the Intended console. Navigate to the Audit section. You should see your governance decision: the intent, the classification, the risk score, and the outcome.

Click on the decision to see the full detail: the policy that was evaluated, the risk scoring breakdown by dimension, and the authority token details.

Navigate to the Insights section. You will see your agent ("quickstart-agent") listed with one decision. As you submit more intents, this view will show the agent's behavior patterns, risk trends, and governance statistics.

What Just Happened

In those five steps, you experienced the complete Intended governance flow.

Intent submission. Your code submitted a structured intent describing what an AI agent wants to do: deploy a service to staging.

Classification. Intended classified the intent into the Open Intent: domain "sdlc," category "deployment," action "sdlc.deployment.service.deploy."

Policy evaluation. The Authority Engine evaluated the intent against the default SDLC domain pack policies. A staging deployment by a standard agent falls within the default allow criteria.

Risk scoring. The risk scoring model evaluated eight dimensions: scope (single service: low), reversibility (deployment is rollbackable: low), data sensitivity (no data access: low), environment (staging: low), regulatory (none: low), historical patterns (first action for this agent: neutral), velocity (single action: low), agent trust (new agent: neutral). Composite score: 12.

Token issuance. Because the decision is "allow," an authority token was issued. The token is cryptographically signed and has a TTL of 300 seconds.

Audit recording. The entire decision was recorded in the hash-chained audit ledger: the intent, the classification, the policy evaluation, the risk score, and the token.

Try Different Scenarios

Now that you have the basics, try submitting intents with different parameters to see how the governance decisions change.

Change the environment to production:

resource: {
  type: "service",
  identifier: "api-gateway",
  environment: "production",
}

You will see a higher risk score and potentially a different outcome. Production deployments carry more risk than staging deployments.

Change the action to a delete operation:

const decision = await sdk.authorize({
  action: "delete the api-gateway service in production",
  actor: "quickstart-agent",
});

Deletion actions score higher on the reversibility dimension and may trigger escalation depending on the default policies.

Submit multiple intents rapidly:

for (let i = 0; i < 10; i++) {
  await sdk.authorize({ action: "list open pull requests", actor: "quickstart-agent" });
}

Watch the velocity dimension in the risk score. Rapid-fire actions from a single agent increase the velocity score.

Next Steps

You have a working Intended integration. Here is what to do next.

Integrate with your AI framework. If you are using LangChain, PydanticAI, CrewAI, or the OpenAI Agents SDK, add the Intended governance wrapper to your tool functions. See the framework integration guides in our documentation.

Customize policies. The default domain pack policies are a starting point. Customize them for your organization's risk tolerance and operational requirements. See the policy-as-code guide.

Add more agents. Register your real AI agents in the Intended console. Each agent gets its own identity, trust level, and behavioral baseline.

Set up monitoring. Configure dashboards and alerts for your governance metrics. See the monitoring guide.

Five minutes to your first governed AI agent decision. That is how fast governance should be.