Getting Started

Install Agent Maturity Compass, run your first assessment, and get a trust score for your AI agent — all in under 2 minutes.

Try AMC before installing. If you just want to try AMC without installing anything, use the Web Playground — answer questions in your browser, explore scenarios, and get an instant score. Use the CLI when you want execution evidence, traces, datasets, and CI gates.

Prerequisites

AMC runs anywhere Node.js runs. You need:

Node.js 20+ — Download Node.js
npm — included with Node.js
A terminal (macOS Terminal, Windows PowerShell, Linux shell)

Check your version:

node --version   # Should be v20.x or higher
npm --version    # Should be v9+ or higher

Installation

macOS and Linux

curl -fsSL https://agentmaturity.co/install.sh | sh

Windows PowerShell

irm https://agentmaturity.co/install.ps1 | iex

Both installers pin the GitHub release, download the platform archive and SHA256SUMS, and refuse to run the packaged installer when verification fails. Verify the installed CLI:

amc --version
amc doctor

In a new directory, amc doctor verifies install readiness and exits successfully without pretending workspace configuration already exists. After initialization, it runs the full workspace checks. CI and production deployments should use amc doctor --strict.

Docker (zero setup)

# Build the quickstart image
docker build -t amc-quickstart -f docker/Dockerfile.quickstart .

# Run the full score
docker run -it --rm amc-quickstart amc

# Non-interactive
docker run -it --rm -e AMC_VAULT_PASSPHRASE=demo amc-quickstart amc

From source

git clone https://github.com/AgentMaturity/AgentMaturityCompass.git
cd AgentMaturityCompass
npm ci
npm run build
npm link

Your First Full Score in 2 Minutes

One command from your agent project. That's it.

Create a project

mkdir my-agent && cd my-agent

Run AMC

amc

AMC creates the workspace if needed, detects what is available, runs the full maturity score, and prints the next action.

Open Studio when ready

amc up

Studio shows the same score, lifecycle evidence, reports, assurance packs, domain packs, run history, and advanced org runs in a local dashboard. The packaged macOS and Windows desktop apps launch Agent Maturity Compass Studio and open this same local console in your system browser.

Need a fast demo check? Run amc quickscore --rapid only when you want a lightweight pulse check. Use amc for the full score.

Expanded lifecycle assessment: Run amc run --question-set lifecycle when you want the explicit 264-question set covering lifecycle governance, evidence binding, runtime watch, proof exports, reasoning memory, and fleet operation. Default scoring stays on the stable 244-question set.

Understanding Your Results

Your full score output includes:

Overall Maturity Level

An L0–L5 maturity score with a percentage breakdown. No level is a legal threshold; external claims also require evidence readiness READY.

Dimension Scores

5 dimension scores covering strategy, skills, resilience, leadership, and alignment.

Gap Analysis

Specific gaps with severity, proof chains, evidence episodes, resource refs, and concrete actions to fix each one.

README Badge

A shields.io badge showing your agent's trust level. Run amc badge to generate it.

What each level means

Absent

Initial

Developing

L3
Defined

Managed

Optimizing

The 8 AMC Surfaces

AMC stays simple by keeping every feature under one trust stack.

Surface	Promise	What it does
Score	Score trust before you ship	Evidence-weighted scoring across live execution behavior instead of brochure claims.
Shield	Attack your agent before attackers do	Runs adversarial packs against prompt injection, leakage, memory poisoning, and sycophancy.
Enforce	Wrap agent actions in policy	Approval gates, scoped permissions, and runtime controls for sensitive operations.
Vault	Cryptographically prove what happened	Signs evidence, verifies ledgers, and gives auditors a tamper-evident chain of custody.
Watch	See trust drift before it hurts you	Monitors posture over time and surfaces anomalies, regressions, and risky changes.
Comply	Map trust evidence to real frameworks	Turns technical evidence into regulator-readable artifacts for audits and risk reviews.
Fleet	Govern many agents like an actual platform	Benchmarks multiple agents, compares risk posture, and enforces org-wide trust baselines.
Passport	Make trust portable between environments	Issues a portable, signed trust identity that can move between tools, teams, and environments.

Next Steps

Once you have your first score, here's what to explore:

Auto-fix your gaps

Run amc fix to generate guardrails, CI gates, and governance docs. Use amc guide --go to auto-apply guardrails to your framework config.

Connect your agent

Use amc evidence collect for a guided wizard, or set up an adapter for your framework. One environment variable — zero code changes.

Verify runtime controls

Run amc guardrails list to separate signed control requests from effective Runtime Firewall bindings. Catalog-only controls stay inactive instead of being presented as protection.

Generate reports

Name a run with amc run-alias set q1-assessment latest, then run amc report q1-assessment --share --public-base-url https://reports.example.com/amc for a static share bundle, or amc report q1-assessment --executive for a terminal summary.

Check compliance

Use amc compliance report --framework EU_AI_ACT for EU AI Act mapping, or explore the full compliance guide.

Useful commands after your first score

Command	What it does
`amc fix`	Generate remediation files (guardrails, CI gate, governance docs)
`amc guide --go`	Auto-detect framework and apply guardrails to config
`amc guide --status`	One-line health check
`amc doctor`	Check runtime and workspace health
`amc up`	Start AMC Studio (gateway, proxy, dashboard, API)
`amc guardrails list`	Show requested, effective, bound, and signature-verified guardrail status
`amc guardrails enable prompt-injection-detection`	Persist a signed additive Runtime Firewall control request
`amc evidence collect`	Interactive wizard to connect your agent
`amc evidence lifecycle list\|inspect\|export --redacted`	Open or export the lifecycle artifacts behind full-score runs
`amc evidence episodes list\|inspect\|export --redacted`	Open or export the evidence episodes behind full-score runs
`amc evidence decisions list\|inspect`	Open recommendation and evidence-request receipts
`amc evidence decisions observe <run>`	Update older receipts with observed outcomes from a later full-score run
`amc evidence observability list\|inspect`	Open component attribution, experience signals, and decision-chain records
`amc memory writeback <episode>`	Store a redacted, evidence-backed reasoning lesson with expiry and a receipt
`amc memory retrieve --consumer studio`	Retrieve active memory lessons with citations for score, recommendations, fixer, or Studio
`amc run-alias set <alias> <run>`	Name a diagnostic run for report, history, and customer-success workflows
`amc report <run\|alias\|latest>`	Review confidence, uncertainty, low-evidence downgrades, and auto-fix review gates
`amc report <alias> --share --public-base-url <url>`	Generate a static report bundle with local and public URLs for client review
`amc trace index\|failures`	Inspect distilled trace indexes and recurring failure clusters
`amc mechanic rca run <run>`	Create RCA, regression tests, rollback pointers, and governed Enforce fix proposals
`amc mechanic rca list\|show`	Review signed Fixer RCA reports
`amc experiment optimize --rca latest`	Create isolated candidates with held-out validation, leakage checks, Pareto ranking, and receipts
`amc experiment optimizer-list\|optimizer-show`	Review accepted and rejected optimizer candidates
`amc resource snapshot\|validate\|apply\|rollback`	Record, gate, accept, and rollback the resources governed by Enforce
`amc firewall enable --mode block`	Protect live Bridge/Gateway traffic with allow, warn, or block decisions
`amc firewall events\|export --redacted`	Inspect and export signed runtime decisions for audit or SIEM review
`amc firewall migrate-signature --approve-legacy-kind`	Verify and preserve an exact legacy policy in the monotonic journal
`amc shield confirm scope-write --file security-scope.json`	Authorize controlled exploit confirmation with ownership, time window, safe mode, and allowed techniques
`amc shield confirm run --scope <scope> --task finding-task.json`	Convert an authorized finding into safe proof with hashes, signal refs, and receipts
`amc shield confirm export <proof> --out safe-proof.json`	Export redacted confirmation proof without exploit instructions
`amc import <path> --dry-run`	Detect neutral traces, runs, graphs, configs, memory, evaluator outputs, and benchmarks before writing
`amc import <path>`	Write redacted imported evidence into episodes, lifecycle runs, resource manifests, and trace indexes
`amc strategy compare --file strategies.json`	Compare inference strategies by score, cost, latency, risk, confidence, and evidence
`amc strategy compare --file strategies.json --apply --approve`	Commit the recommended model route only with policy approval, manifest evidence, and rollback data
`amc runtime create\|event\|inspect`	Persist connected-agent run state and redacted event streams shared by CLI and Studio
`amc fleet graph write --file graph.json`	Register typed nodes, handoffs, tools, contracts, policies, permissions, and invariants
`amc fleet graph validate`	Check graph contracts, unsafe permissions, cycles, and fan-out before fleet scoring
`amc fleet score --all --stream`	Full-score every configured agent with progressive results
`amc fleet lifecycle list\|show`	Inspect parent/child fleet lifecycle evidence, topology, typed graph digest, and cascade failures
`npm run release:gate`	Run the release gate for CLI, Studio assets, OpenAPI, docs drift, domain packs, and receipt output
`amc badge`	Generate a maturity badge for your README
`amc assurance run --scope full`	Run the built-in red team across the full assurance library
`amc observe timeline`	See score progression, evidence volume, and recent anomalies
`amc trace inspect`	Inspect sessions, tool calls, decisions, and trust tiers
`amc dataset create`	Create a golden dataset for business-specific eval cases
`amc dataset run`	Run a curated dataset against your model or gateway endpoint
`amc lite-score`	Score a plain chatbot or LLM app without full agent wiring
`amc business kpi`	Map maturity levels to risk reduction and audit readiness
`amc leaderboard show`	Compare agent maturity scores across your fleet