Skip to content
Skillpedia
Agents48k · #4676

polis-protocol

Coordinates multiple AI agents as a team. It learns which agent is best for each task and lets users adjust the rules.

What it does

Coordinates multiple AI agents to work together as a learning team. A smart 'router' decides which agent is best for each task based on past performance. The team's rules can also be changed by the agents themselves.

When to use it

  • ✓When multiple AI agents (from different providers) work on a project.
  • ✓When you want the team to improve over time by learning from outcomes.
  • ✓When you need a clear record of who did what and which rules have changed.

Example of what to ask your AI

“How can the AI team decide which agent is best to translate this document?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/sickn33/agentic-awesome-skills/blob/main/skills/polis-protocol/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/sickn33/agentic-awesome-skills/blob/main/skills/polis-protocol/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

Each agent has a profile detailing its skills. When a task is received, an intelligent system chooses the agent with the best track record for that type of work. The system learns from each completed task to improve future choices.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add sickn33/agentic-awesome-skills --skill polis-protocol

Or download just the file:

curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/skills/polis-protocol/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Polis Protocol — a team of agents that develops

Overview

Most agent coordination is a passive board: claim a task, do it, mark it done. It records, but it never gets smarter, and its rules are frozen. Polis Protocol is the active alternative — a folder of markdown where each agent is a "citizen" with a capability card, work is routed by a learning bandit to whoever has the best track record on the task's tags, settled work files lessons that update the routing, and citizens can propose and vote on amendments to the protocol itself. It is vendor-agnostic: Antigravity, Claude, Codex, and Gemini agents can all share one _polis/.

In Antigravity specifically, this turns Manager View's fixed pipeline into a team that learns who is actually best at each kind of work, instead of running the same roles in the same order every time.

When to Use This Skill

  • Use when 2+ agents (especially across vendors) work on one project and "who should do this" is a real question.
  • Use when you want the team to measurably improve over time — routing that adapts from outcomes, not static role labels.
  • Use when you need a durable, git-auditable record of who did what, what was learned, and which rules changed.
  • Use when Antigravity's default orchestration is too rigid and you want routing + governance on top of it.

How It Works

Step 1: Found a polis

Use a reviewed checkout by default so the scaffolder code is pinned before it writes into the project:

git clone https://github.com/yehudalevy-collab/polis-protocol.git
cd polis-protocol
git checkout <reviewed-commit-sha>
python3 scripts/init_polis.py \
  --project-root . \
  --agent-id gemini-antigravity-yourproject \
  --vendor google --model gemini-3 --tool antigravity

If you prefer the published PyPI package, install an exact version after reviewing that release, for example pipx install polis-protocol==<reviewed-version>. Do not invoke the package through an unpinned uvx or "latest" workflow for automated setup.

This writes _polis/ plus the skill into .agents/skills/ (the path Antigravity reads), and bridge pointers (GEMINI.md, AGENTS.md) that point every tool at _polis/CONSTITUTION.md. Tip: add --dry-run to preview every file before anything is written; init never overwrites existing files, and polis init --repair restores missing ones.

Step 2: Register citizens and open contracts

Each agent publishes a capability card under _polis/citizens/. Work is opened as a contract with required_tags, not assigned to a fixed role.

Step 3: Route by track record

polis route --polis-root _polis \
  --contract _polis/contracts/open/your-task.md --explain

The router prints a score breakdown (history / self-rating / cost / availability / applied lessons) and recommends the citizen with the strongest record on the task's tags. Agents can also reserve files (polis reserve src/auth --as <citizen>) so two agents never edit the same path at once — overlapping claims are rejected with the holder named.

Step 4: Settle, learn, and amend

polis contract settle <contract-id> --quality 5
polis reconcile --polis-root _polis

A settled contract files a lesson; accepted lessons carry a bounded routing_effect the router reads — and names in --explain — on the next similar task. Failures become guardrails (polis guardrail add …) that future contracts on those tags inherit as must-pass acceptance criteria. When a rule stops working, a citizen proposes an amendment and the others vote. Reproduce the learning claim yourself: polis bench --mode learning.

Examples

Example 1: See the team learn (no install, 30 seconds)

git clone https://github.com/yehudalevy-collab/polis-protocol.git
cd polis-protocol
git checkout <reviewed-commit-sha>
bash scripts/demo.sh

The router recommends Gemini for a Spanish-translation contract — because settled work taught it she has the best record on that tag, not because anyone reassigned it.

Example 2: Explain any routing decision

python3 scripts/route_contract.py --polis-root examples/research-team/_polis \
  --contract examples/research-team/_polis/contracts/open/parent-newsletter-issue-3.md --explain

Notes

  • No server, no runtime, no database — the whole protocol is markdown plus two small Python scripts.
  • Vendor-agnostic by design; a Claude or Codex agent can join the same polis an Antigravity agent created.

…

FAQ

What are 'citizens'?

These are the AI agents that are part of the team. Each has a 'capability card' describing what it can do.

How do the team's rules change?

Agents can propose rule changes and vote on them, allowing the team to adapt and improve.

Do I need to install something complicated?

No, the system works with simple text files (markdown) and a few small scripts, without needing complex servers or databases.

Details

Original description by the author

Coordinate multi-vendor AI agents as a self-improving team — a learning router assigns work by track record and citizens can amend the protocol's own rules.

repo: sickn33/agentic-awesome-skills

Popularity

GitHub stars
48k
Ranking position
#4676
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills