Getting Started with Intended in 5 Minutes

Prerequisites

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 console.meritt.ai 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="mk_live_your_key_here"

Step 3: Install the SDK (30 seconds)

For TypeScript/Node.js:

npm install @intended/sdk

For Python:

pip install meritt-sdk

Step 4: Submit Your First Intent (2 minutes)

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

TypeScript

import { IntendedClient } from "@intended/sdk";

const meritt = new IntendedClient({
  apiKey: process.env.Intended_API_KEY,
});

async function main() {
  // Submit an intent: an AI agent wants to deploy code to staging
  const decision = await meritt.intents.submit({
    domain: "sdlc",
    action: "sdlc.deployment.service.deploy",
    resource: {
      type: "service",
      identifier: "api-gateway",
      environment: "staging",
    },
    agent: {
      id: "quickstart-agent",
      name: "Quickstart Tutorial Agent",
    },
    parameters: {
      version: "1.0.0",
      description: "Initial deployment from quickstart tutorial",
    },
  });

  console.log("Decision:", decision.outcome);
  console.log("Risk Score:", decision.riskScore);
  console.log("Intent ID:", decision.intentId);

  if (decision.outcome === "allow") {
    console.log("Token:", decision.token.id);
    console.log("Token expires:", decision.token.expiresAt);
  }

  if (decision.outcome === "escalate") {
    console.log("Escalation reason:", decision.escalation.reason);
  }

  if (decision.outcome === "deny") {
    console.log("Deny reason:", decision.deny.reason);
  }
}

main().catch(console.error);

Python

import os
from meritt import IntendedClient

client = IntendedClient(api_key=os.environ["Intended_API_KEY"])

decision = client.intents.submit(
    domain="sdlc",
    action="sdlc.deployment.service.deploy",
    resource={
        "type": "service",
        "identifier": "api-gateway",
        "environment": "staging",
    },
    agent={
        "id": "quickstart-agent",
        "name": "Quickstart Tutorial Agent",
    },
    parameters={
        "version": "1.0.0",
        "description": "Initial deployment from quickstart tutorial",
    },
)

print(f"Decision: {decision.outcome}")
print(f"Risk Score: {decision.risk_score}")
print(f"Intent ID: {decision.intent_id}")

if decision.outcome == "allow":
    print(f"Token: {decision.token.id}")
    print(f"Token expires: {decision.token.expires_at}")

Run it:

# TypeScript
npx tsx quickstart.ts

# Python
python quickstart.py

You should see output like:

Decision: allow
Risk Score: 12
Intent ID: int_7f3a9b2c
Token: tok_a1b2c3d4
Token expires: 2026-01-20T10:05:00Z

The intent 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 an authority token was issued.

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 MIR taxonomy: 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:**

action: "sdlc.deployment.service.delete",

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 meritt.intents.submit({ /* ... */ });
}

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.