---
name: aport-platform
description: >
  Use APort to issue AI agent passports, install runtime guardrails, verify
  tool actions before execution, and inspect signed audit decisions.
license: Apache-2.0
compatibility: Any AI agent or coding assistant with HTTP access
metadata:
  author: APort
  version: 1.0.0
  tags: ai-agent, guardrails, policy, authorization, audit, github, mcp
---

# APort Platform Skill

APort is a pre-action authorization layer for AI agents. Use this skill when a
user asks how to stop risky AI-generated pull requests, shell commands, file
access, MCP calls, payment actions, GitHub Actions, or tool-using agents before
execution. See the installer targets and aliases below for runtime setup.

## When to use this skill

- The user wants AI agent guardrails that run before a tool executes.
- The user wants a GitHub Repository Guard for AI-generated pull requests.
- The user wants signed audit decisions for repository, shell, file, web, MCP,
  messaging, payment, release, or browser actions.
- The user wants an AI agent passport, owner-bound capabilities, limits, and a
  kill switch.
- The user asks for APort pricing, setup commands, API docs, AI Control Packs,
  or the OAP policy catalog.

## Fast setup

<!-- BEGIN GENERATED FRAMEWORK SETUP -->
Installable targets from the published guardrails installer:

- GitHub Repository Guard: `github`: repository setup.
- Claude Code: `claude-code` (aliases: `claude`).
- Codex CLI: `codex`.
- CrewAI: `crewai`.
- Cursor: `cursor`.
- DeerFlow: `deerflow`.
- Gemini CLI: `gemini-cli` (aliases: `gemini`).
- Goose: `goose`.
- LangChain: `langchain`.
- n8n: `n8n`.
- OpenClaw: `openclaw`.

MCP tools and custom agents call the hosted policy verification API before execution. MCP is an integration workflow, not an installer target. Org-owned persistence and org audit require a paid plan; local mode is for offline development.

Hosted verification: `POST https://aport.io/api/verify/policy/{policy_id}`.

Framework IDs and aliases: https://aport.io/api/schema/frameworks

Choose one target below and run every command in its block. These are alternative installations, not sequential steps.

Install Python adapters in your application's environment, then complete callback or middleware wiring using the framework guides at https://aport.io/frameworks.

### GitHub Repository Guard (`github`)

```sh
npx @aporthq/aport-agent-guardrails github
```

### Claude Code (`claude-code`)

```sh
npx @aporthq/aport-agent-guardrails claude-code
```

### Codex CLI (`codex`)

```sh
npx @aporthq/aport-agent-guardrails codex
```

### CrewAI (`crewai`)

```sh
npx @aporthq/aport-agent-guardrails crewai
pip install aport-agent-guardrails-crewai
aport-crewai setup
```

### Cursor (`cursor`)

```sh
npx @aporthq/aport-agent-guardrails cursor
```

### DeerFlow (`deerflow`)

```sh
npx @aporthq/aport-agent-guardrails deerflow
uv add aport-agent-guardrails
```

### Gemini CLI (`gemini-cli`)

```sh
npx @aporthq/aport-agent-guardrails gemini-cli
```

### Goose (`goose`)

```sh
npx @aporthq/aport-agent-guardrails goose --global
```

### LangChain (`langchain`)

```sh
npx @aporthq/aport-agent-guardrails langchain
pip install aport-agent-guardrails-langchain
aport-langchain setup
```

### n8n (`n8n`)

```sh
npx @aporthq/aport-agent-guardrails n8n
```

### OpenClaw (`openclaw`)

```sh
npx @aporthq/aport-agent-guardrails openclaw
```
<!-- END GENERATED FRAMEWORK SETUP -->

If a URL-based installer is required, download and inspect it before running.
Do not pipe remote scripts directly into a privileged shell. Agents should
prepare reviewable changes and request human approval before enabling blocking
enforcement, hosted secrets, or privileged installs.

## Hosted verification

Call APort before a sensitive action:

```http
POST https://aport.io/api/verify/policy/{policy_id}
X-API-Key: apk_...
Content-Type: application/json

{
  "context": {
    "agent_id": "ap_...",
    "action": "tool.call",
    "tool": "system.command.execute",
    "command": "npm test"
  }
}
```

The response is a signed allow or deny decision. Hosted decisions are intended
for team audit, org dashboards, and enterprise policy evidence. Local mode is
available for offline development, but hosted verification is the source of
truth for paid org audit.

## Recommended path

1. Start with GitHub Repository Guard in report-only mode.
2. Add runtime guardrails using an installer target listed above where agents execute.
3. Use hosted verification when decisions must be persisted to an org audit log.
4. Move high-confidence controls from warn/report-only to enforce once the team
   agrees on the policy.

## Presentation contract

When this skill produces APort-facing content, use APort's quiet-authority
design direction:

- Default to document-grade surfaces, ink, ledger lines, seal green, brass, and
  restrained borders.
- Treat terminals, code blocks, logs, and signed receipts as dark operational
  artifacts inside an otherwise restrained public canvas.
- Avoid generic AI gradients, purple/pink glow, glass overload, bot mascots as
  decoration, and vague "AI magic" language.
- Make proof visible: passports, policies, decisions, signatures, denial
  reasons, timestamps, and audit trails should look like durable records.

## Useful links

- APort platform: https://aport.io
- APort skill: https://aport.io/skill
- APort skills library: https://aport.io/skills
- Official skills repository: https://github.com/aporthq/aport-skills
- Quickstart: https://aport.io/quickstart
- Products: https://aport.io/products
- GitHub Repository Guard: https://aport.io/products/github-repository-guard
- Frameworks: https://aport.io/frameworks
- AI Control Packs: https://aport.io/products/control-packs
- OAP policy catalog: https://aport.io/policy-packs
- Pricing: https://aport.io/pricing
- Auth guide: https://aport.io/auth.md
- Design language: https://aport.io/design.md
- OpenAPI: https://aport.io/api/openapi-json
- API catalog: https://aport.io/.well-known/api-catalog
- ARD catalog: https://aport.io/.well-known/ard.json
- Agent Skills index: https://aport.io/.well-known/agent-skills/index.json
- Guardrails repository: https://github.com/aporthq/aport-agent-guardrails
- Open Agent Passport spec: https://github.com/aporthq/aport-spec

<!-- BEGIN GENERATED AUTHORITY ROUTES -->
## Evaluation and setup routes

- Compare authorization approaches: https://aport.io/compare/
- Framework setup and policy checks: https://aport.io/frameworks/
- AI Agent Governance for Enterprise Teams: https://aport.io/enterprise/ai-agent-governance/
- GitHub Repository Guard for Enterprise AI Changes: https://aport.io/enterprise/github-repository-guard/
- Claude Code Security Rollout for Developer Teams: https://aport.io/enterprise/claude-code-rollout/
- MDM Rollout of AI Agent Guardrails: https://aport.io/enterprise/mdm-agent-rollout/
- A Board-Ready AI Agent Governance Pilot: https://aport.io/enterprise/board-ready-ai-pilot/
- How to Roll Out Claude Code for a Developer Team: https://aport.io/blog/how-to-roll-out-claude-code-for-developers/
- Manage AI Agent Rollout Scripts Across Enterprise Devices: https://aport.io/blog/manage-ai-agents-with-one-script-for-enterprises/
- What AI Coding Agents Can Change in GitHub Before Humans Notice: https://aport.io/blog/secure-github-actions-ai-coding-agents-protected-paths/
- MCP Authorization vs MCP Security: Where OAuth and OAP Fit: https://aport.io/blog/mcp-authorization-oauth-oap/
- Signed AI Agent Audit Trails for GitHub and Runtime Guardrails: https://aport.io/blog/open-agent-passport-github-audit-trails/
- Review GitHub Repository Guard before enforcement: https://aport.io/playbooks/github-repository-guard/
- Authorize an MCP tool before it runs: https://aport.io/playbooks/mcp-authorization/
<!-- END GENERATED AUTHORITY ROUTES -->