# Protocol

> An open standard for rebuilding a business around AI, driven by any coding agent. The protocol is open; Augustus is the reference engine.

- **Type:** MCP server
- **Install:** `agentstack add mcp-augustus-so-protocol`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [augustus-so](https://agentstack.voostack.com/s/augustus-so)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [augustus-so](https://github.com/augustus-so)
- **Source:** https://github.com/augustus-so/protocol

## Install

```sh
agentstack add mcp-augustus-so-protocol
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# The Augustus Protocol

**Protocol version 1.2.0**

An open standard for driving a business through an AI operating layer from any coding agent.

Point Claude Code, Cursor, or Codex at Augustus. It grounds itself in your business, audits a process, designs an AI system for it, tests that system against your real data, and runs it with a human in the loop. You approve what matters. It does the rest.

This repository is the standard itself: the lifecycle, the gates, and the full tool interface, in plain language and in machine-readable schema. It is open so anyone can read exactly how the protocol works, drive it from any MCP client, or implement a compatible engine of their own.

## Why this is open

The way you rebuild a company around AI should be a shared, inspectable standard, not a black box you have to trust. So the standard is here in full: every stage, every gate, every tool, in plain language and in machine-readable schema.

A spec cannot hand you the part that runs it: a hosted engine, the validation that refuses anything unproven, and the reference implementation that keeps it reliable at scale. The standard is open. The engine is [Augustus](https://augustus.so).

## The lifecycle

The protocol takes one process from raw to live in eight stages. An agent drives every step. The owner answers questions and approves decisions.

1. **Foundation.** The agent reads your website and everything you hand it, and grounds itself in what your business is.
2. **Audit.** For the process you pick, the agent writes a deep audit on its own model, against a fixed methodology.
3. **Ground.** The protocol refuses to build on a guess. If a fact is missing, it asks you in plain language until the audit stands on real answers.
4. **Build.** The agent designs the automation using only tools that are connected, and submits it into safe preview.
5. **Test.** The system runs against real data in preview. It touches nothing real until it is proven.
6. **Go live.** A proven system goes live on its trigger. Every irreversible action still waits for a human.
7. **Wire the trigger.** The agent connects your real event source so the system fires.
8. **Operate.** Approvals, decisions, and revisions run through the agent. The system improves as it runs.

The full contract is in [SPEC.md](SPEC.md). Every tool is in [TOOLS.md](TOOLS.md), with machine-readable schema in [`schema/tools.json`](schema/tools.json).

## Where the work runs

- **Designing runs on your agent.** Writing the audit and designing the automation run on your own coding agent. The engine hands it a brief: the methodology, your grounded context, and an output schema. Your agent produces the result. The engine validates it and enforces every gate.
- **Running runs on your model.** A live system runs later with no agent present, on your own AI key. Augustus is the layer, not the model. You bring the model.

## Quickstart

The reference engine runs as an MCP server. Connect your coding agent to it and start.

**Claude Code**

```bash
claude mcp add --transport http augustus https://app.augustus.so/api/mcp
```

**Cursor, Codex, or any MCP client**

Add the server to your MCP config:

```json
{
  "mcpServers": {
    "augustus": {
      "url": "https://app.augustus.so/api/mcp"
    }
  }
}
```

Then tell your agent: **"Set up my business on Augustus."** It takes it from there. Anyone can run the audit for free. Building a real system creates a tracked account, which the agent handles in the conversation.

## What is in this repo

| File | What it holds |
| --- | --- |
| [SPEC.md](SPEC.md) | The protocol: principles, the eight-stage lifecycle, and the gates. |
| [TOOLS.md](TOOLS.md) | Every tool an agent calls, grouped by stage, with parameters. |
| [`schema/tools.json`](schema/tools.json) | Machine-readable schema for all 45 tools. |
| [CONTRIBUTING.md](CONTRIBUTING.md) | How to propose changes to the standard. |
| [CHANGELOG.md](CHANGELOG.md) | Version history. |

## Reference engine

[Augustus](https://augustus.so) is the reference implementation. It hosts the runtime and the validation. How to connect and what it costs live there, not in this standard.

Licensed under [MIT](LICENSE).

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [augustus-so](https://github.com/augustus-so)
- **Source:** [augustus-so/protocol](https://github.com/augustus-so/protocol)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-augustus-so-protocol
- Seller: https://agentstack.voostack.com/s/augustus-so
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.