polis-protocol-a-self-optimizing-city-of-agents
Makes your agent work as part of a self-optimizing smart city. It coordinates the actions of multiple agents.
What it does
This system allows different artificial intelligences (agents) to work together on a long-term project. They organize like a city, where each agent has a role and learns from past experiences to improve teamwork.
When to use it
- ✓When you need multiple AIs to collaborate on a complex project.
- ✓To optimize which AI does which task, based on their skills.
- ✓When you want the work process to automatically improve over time.
Example of what to ask your AI
“How can we have the Claude AI and the Gemini AI work together to write a book about the history of Brazil?”
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
Ready-to-paste message
How it works
The system works like a city where each AI is a citizen. They follow rules (protocol), introduce themselves with their skills (capability cards), accept tasks (contracts), and record what they learned (chronicles) so everyone improves together.
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-a-self-optimizing-city-of-agentsOr download just the file:
curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/polis-protocol-a-self-optimizing-city-of-agents/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Bundled upstream support
Supporting files are included at skill-relative paths. See UPSTREAM-NOTICE.md for their pinned sources, licenses, hashes, and import changes.
Polis Protocol: A Self-Optimizing City of Agents
When to Use
Use this skill when you need polis Protocol: A Self-Optimizing City of Agents.
A protocol that lets AI agents from different vendors collaborate on a long-running project, route work to whoever is best at it, and get measurably better over time. Everything lives in a folder of markdown files, so any tool that reads and writes text can participate — no central server, no required runtime.
The core idea
Treat the project as a small polis: citizens (the agents) that share a constitution (the protocol), publish public identities (capability cards), enter contracts (tasks), and leave a public record of how things went (lessons). Three institutions plus a self-change mechanism:
- The Register — identity and capability discovery (capability cards).
- The Contract — structured tasks with learned routing.
- The Chronicle — lessons that compound and feed back into routing.
- The Amendment — citizens change the rules when reality demands it.
This buys what shared-vault setups don't: cross-vendor optimization (work goes to whoever is best at it), self-development (routing improves with use), and constitutional evolution (the protocol updates itself from friction). For pure note-passing without routing, prefer agent-vault.
When this skill is active
Any multi-agent scenario where "who should do this" is a real question: founding or joining a polis; writing, claiming, or settling a contract; running a chavruta review; proposing or ratifying an amendment; or diagnosing a stalled contract, sync conflict, router pathology, or stuck quorum. Upgrading from agent-vault → references/troubleshooting.md ("Migrating from agent-vault").
Structure of a polis
A polis lives in a _polis/ folder at the project root; everything outside it is project content the protocol never touches.
CONSTITUTION.md— canonical tool-agnostic protocol ·index.md— current state ·README.md— human explainerchronicle.md— append-only event logcitizens/<agent-id>/—capability_card.yml,status.md,inbox.md,journal.mdcontracts/open/<id>.md·contracts/settled/<id>.md·contracts/routing_stats.yml(learned policy, updated on settle)lessons/<capability-tag>/<id>.md·reviews/<YYYY-MM-DD-HHMM>-<contract>.md·amendments/proposed|ratified/- Project root also gets
CLAUDE.md/AGENTS.md/GEMINI.mdbridge pointers and.agents/skills/polis-protocol/SKILL.md(Codex/Antigravity copy), all pointing atCONSTITUTION.md.
Citizens link to project files with wikilinks ([[path/to/note]]). The _polis/ folder is the only thing the protocol owns.
The first thing to do every session
Before touching any project file, run the entry routine, in order:
- Polis exists? Look for
_polis/CONSTITUTION.md. If absent, scaffold it (see "Founding a polis"). - You are registered? Look for
_polis/citizens/<self>/capability_card.yml. If absent, register (see "Registering a citizen"). - Read
_polis/CONSTITUTION.mdonce per session — it is the canonical protocol for this polis; this SKILL.md is the seed it grew from. - Read
_polis/index.md— where things stand (a two-minute read). - Read your inbox —
_polis/citizens/<self>/inbox.md. - Scan the tail of
chronicle.mdbackward until you reach thelast_seen_event:in yourstatus.md. That is your catch-up. - Read your open contracts — anything in
_polis/contracts/open/withowner: <self>. - Update
last_seen_eventandlast_activein yourstatus.md. - Report back to the user — state of the project, what's in flight, what needs their input, a concrete first move.
If chronicle.md has grown large, the rollover policy (references/troubleshooting.md) keeps it bounded.
The chronicle: recording what you did
After each meaningful action, append exactly one line to _polis/chronicle.md. The format is rigid because the router and other citizens parse it:
- YYYY-MM-DD HH:MM | <agent-id> | <verb-phrase> | [[<wikilink>]] | <one-line note or - >
- 2026-05-14 09:15 | codex-frontend-pesaj | settled contract | [[contracts/settled/auth-refactor]] | tests passing, lesson filed
…
FAQ
What are 'agents'?
Agents are the individual artificial intelligences participating in the project.
What is the 'protocol'?
The protocol is the set of rules all agents follow to collaborate and make decisions.
How do the AIs learn and improve?
They record lessons learned from each task and use this information to decide who is best for future tasks, making the process more efficient.
Details
Original description by the author
Polis Protocol: A Self-Optimizing City of Agents
Popularity
- GitHub stars
- 48k
- Ranking position
- #3852
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
00-andruia-consultant
Helps your agent start or improve AI projects. It analyzes code, suggests tools, and creates action plans in Spanish.
sickn33/agentic-awesome-skills
007
Lets your agent perform security audits and threat modeling. It's useful for protecting projects against attacks and vulnerabilities.
sickn33/agentic-awesome-skills
10-andruia-skill-smith
Helps your agent create or improve AI tools. It defines how tools work, writes documentation, and validates the structure.
sickn33/agentic-awesome-skills
20-andruia-niche-intelligence
Lets your agent create a summary about a specific industry. It's useful for understanding the context, rules, usage patterns, and risks of a project, using reliable sources.
sickn33/agentic-awesome-skills
Similar skills
agent-architecture-audit
Makes your agent check if everything is working correctly. It finds and fixes problems in AI systems, ensuring they perform as expected.
affaan-m/ECC
agent-eval
Helps your agent compare different AI coding tools. It measures which one is faster, cheaper, and more reliable for specific tasks.
affaan-m/ECC
agent-harness-construction
Makes your agent better understand how to perform tasks. It optimizes the tools and instructions the agent uses to increase its chances of success.
affaan-m/ECC