Montoyer - Open source multi-agent framework for EU policy and legislation

What Is Montoyer

Imagine you're a policy officer inside the European Commission. You have a promising legislative idea, but before you can even draft a single article, you need to know: will Competition push back? Will the Legal Service raise a treaty-basis flag? Will the College deliberate in your favor or send your proposal back to the drawing board?

Right now, answering those questions means weeks of informal consultations, corridor diplomacy, and gut-feel risk assessment. The EU's legislative machinery is one of the most sophisticated institutional frameworks in the world — but for the people working inside it, predicting how that machinery will react to a new proposal is still largely an opaque, manual process.

Montoyer changes that.

Montoyer is an open-source, domain-specific multi-agent framework built to model the EU Commission's internal workflows, legislative procedures, and institutional dynamics. It doesn't try to be a general-purpose chatbot. Instead, it is a specialized system that understands how the EU quarter actually works — from Inter-service Consultation to College Deliberation to Trilogue negotiations — and turns that institutional knowledge into interactive, multi-agent simulations.

At the core of Montoyer are 21 Commissioner Persona agents, each strictly bound by their Treaty-granted mandate and political priorities. These are supported by 17 DG Operational Agents that provide technical analysis, legal frameworks, and data-driven reporting — not political positions. Together, they operate across 8 domain plugin packages covering everything from legislative drafting and competition law to privacy impact assessments and trade defense.

The result? A system that lets you simulate the entire EU policy-making process before a single formal document is circulated. Want to know how Commissioner for Competition would react to a state aid proposal? Run /commissioner-standpoint competition "proposal summary". Need a full legislative cycle from policy brief to OJ publication? Run /legislative-cycle.

Montoyer has already been featured on 12+ AI tool directories and discovery platforms, including AI Agents Directory, Shipit, Wired Business, Startup Fame, and Findly.tools. The entire framework is available on GitHub under the MIT License — free to use, fork, modify, and extend.

---

Montoyer's Core Capabilities

Montoyer's feature set isn't a random collection of AI tricks. Every capability is designed around one question: what does someone working in or with the EU quarter actually need? Here's what the community has built so far.

Commissioner Personas — 21 Agents, Each With a Mandate

The European Commission is not one monolithic entity. It's 21 individual members, each with a Treaty-defined portfolio, political priorities, and a decision style that shapes how they engage with proposals. Montoyer mirrors this reality.

Each Commissioner Persona is defined as a structured Markdown file under knowledge/commissioners/, following a strict template that includes:

• Mandate: The Treaty articles that define their legal authority
• Political priorities: The agenda items they champion
• Decision style: Whether they lean toward consensus, opposition, or conditional support
• Tensions: Known friction points with other portfolios

Want to simulate how the Commissioner for Energy would react to a Green Deal industrial policy proposal? Montoyer's agent won't give you a generic answer — it will respond within the constraints of their actual mandate and known political stance.

Multi-Agent Session Protocols — Simulating Real EU Procedures

This is where Montoyer truly differentiates itself from any generic AI tool. The framework supports four core multi-agent session protocols, each modeled on real EU institutional procedures:

• College Deliberation: Lead Commissioner presents (3 min) → Each Commissioner speaks (support/reserve/oppose) → President identifies consensus or calls formal vote → Outcome (adoption/return/withdrawal)
• Inter-service Consultation (ISC): Lead DG circulates draft → Affected DGs return written opinions → Lead DG consolidates revisions → Second round if needed
• Trilogue: Commission defends proposal → Parliament submits amendments → Council presents general approach → Compromise text negotiation → Political agreement or breakdown
• Task Force: Cross-DG working group with structured deliverables and deadlines

Each protocol is a step-by-step workflow defined in knowledge/agents/, not a free-form chat. The agents have strict roles, speaking orders, and procedural constraints — just like the real thing.

Slash-Command Skills — Domain Expertise at Your Fingertips

Montoyer's skills are like a policy toolbox strapped to your terminal. Each skill is a domain capability you invoke with a slash command:

Each skill lives inside a domain plugin (plugins/[domain]/skills/[skill-name]/SKILL.md) and follows a strict frontmatter format with triggers, role, scope, output format, and institution mapping. The workflow includes MUST DO and MUST NOT DO constraints that ensure the output stays procedurally correct.

Inline Attribution Architecture — Built-In Hallucination Defense

Legislative drafting is not the place for AI hallucinations. Montoyer's Inline Attribution Architecture is a real-time verification system that runs as native .sh hooks in lib/hooks/:

• post_tool_use_citation_matcher.sh — Matches and validates legal citations against local Treaty schemas
• post_tool_use_eurlex_resolver.sh — Resolves EUR-Lex references via HTTP requests to the Curia server
• post-output-disclaimer.sh — Injects DRAFT disclaimer at the end of every output
• post-subsidiarity-prompt.sh — Appends subsidiarity principle checks
• pre-legal-basis-check.sh — Front-loads legal basis validation

When the agent generates text, these hooks intercept the stream in real-time, isolate legal references, cross-reference them against a locally stored JSON Treaty schema, query Curia for live CJEU records, and inject visible verification or warning tags directly into the output:

• [EUR-Lex — verify current version]
• [CJEU — verify Curia reference]
• [Eurostat YYYY-MM — verify]
• [review — legal uncertainty]

This isn't a post-processing afterthought. It's a fundamental architectural commitment to traceability.

Domain Plugin System — 8 Packages and Growing

Montoyer's functionality is organized into 8 domain plugin packages, each with its own directory structure, CLAUDE.md domain practice file, .claude-plugin/plugin.json manifest, skills, references, and hooks:

1. legislative-eu — Policy officers, legislative drafting, SecGen review, impact assessment, comitology, parliamentary questions
2. competition-eu — Antitrust, state aid, Legal Service opinions, market definition, GBER screening
3. institutional-management-eu — Unit heads, assistants, HR contracts, finance, CDR drafting
4. grants-enforcement-eu — Grant management, infringement procedures, procurement, transposition tracking
5. data-communication-eu — Eurostat data support, scoreboards, press releases, speechwriting, crisis messaging
6. trade-eu — Anti-dumping, countervailing measures, safeguards, injury analysis, dumping margin
7. simulation-eu — Full legislative cycle including College, ISC, Trilogy, Parliament, and Council
8. privacy-eu — DPIA workflows, DPO operations, IT security, legal officer support

Every plugin is registered in marketplace.json and can be installed independently.

---

Who Uses Montoyer

Montoyer's community is diverse — and growing. Here's how different groups are putting it to work.

EU Policy Researchers — Simulating Cross-Commission Dynamics

"Before Montoyer, I'd spend weeks informally sounding out positions across DGs. Now I can run a College deliberation in 15 minutes and see exactly where the friction points are."

If your job involves understanding how new regulatory proposals will land across the College of Commissioners, Montoyer gives you a structured, repeatable way to test scenarios. Use /college-deliberate to simulate all 21 Commissioners debating a policy issue. The output reveals political resistance points, cross-DG tensions, and potential negotiation leverage — before any formal inter-service consultation begins.

Legislative Drafters — From One Sentence to a Draft Regulation

"The first draft of a legislative proposal used to take me three weeks of template-checking, Treaty cross-referencing, and Better Regulation compliance. /legislative-proposal cuts that to minutes."

With /legislative-proposal <brief>, Montoyer runs an end-to-end pipeline: DG technical analysis → impact assessment → Treaty check → stakeholder consultation → ISC → Commissioner endorsement → College vote. The output is a complete legislative package including explanatory memorandum, impact assessment SWD, and consultation summary — all structurally compliant with OLP templates.

Educators and Students — Interactive Learning of EU Procedures

The Ordinary Legislative Procedure, Comitology, Trilogue — these are notoriously hard to teach from textbooks. Students read the steps but struggle to internalize the dynamics.

Montoyer's simulation commands (/legislative-cycle, /trilogue, /college-deliberation) turn passive reading into active participation. Educators run live simulations in class, assign students to role-play Commissioner positions, and watch as Parliament amendments, Council objections, and Commission compromises unfold in real-time. One university lecturer described it as "the difference between reading about a chess game and actually playing one."

IT Consultants Onboarding Into EU Institutions

This is a use case the Montoyer community didn't fully anticipate — but it turned out to be one of the most valuable.

Non-statutory staff and Framework contract IT consultants joining EU institutions face a steep learning curve. Contract types, grade structures, salary bands, Framework contract architecture (DIGIT TM II, DIGIT SM), and the unwritten rules of how the Commission actually operates — these take months to absorb.

The community documentation at doc.montoyer.com has become an unofficial onboarding guide. It covers everything from contract types (EU Civil servant contracts vs. External consultant contracts) to salary structures, EQF levels, Framework contract hierarchies, and practical FAQs.

Civic Tech Projects — Making EU Decision-Making Transparent

For civic tech groups working on EU transparency, Montoyer offers a unique capability: you can reverse-run the agent system. Take a final decision, feed it backward through the simulation, and watch the system reconstruct the positions and reasoning of each agent involved.

This turns an opaque institutional output into a structured, explainable narrative — helping citizens understand why a particular decision was made, which DGs advocated for it, and where the political trade-offs occurred.

---

Montoyer's Technical Architecture

The Montoyer community didn't assemble a random toolkit. They built a layered architecture that mirrors the structure of the EU institutions themselves.

Five-Layer Architecture

Montoyer's design is modular by nature, with five independently extensible layers:

Institutions Layer  →  European Parliament, Council, ECJ, ECB, EEAS
Agents Layer        →  Multi-agent session orchestration (College, ISC, Trilogue)
DG Layer            →  17 DG operational profiles (technical analysis, legal frameworks)
Commissioner Layer  →  21 Commissioner personas (mandate, priorities, decision style)
Skills Layer        →  Slash-command skills organized in domain plugins

Each layer talks to the ones adjacent to it through clearly defined interfaces. Need to add a new DG profile? Drop a Markdown file into knowledge/dgs/. Need a new skill? Create a SKILL.md in the relevant plugin's skills directory. The layered architecture ensures that changes in one layer don't break the others.

Agent Family Design — Specialization Over Generalization

Montoyer doesn't throw one AI model at every problem. Instead, it organizes capabilities into four Agent Families, each with a distinct purpose:

• Commissioner Personas (21 agents): Simulate political-executive dynamics. Each agent is bound by a Treaty mandate, operates with a defined decision style, and carries known tensions with other portfolios.
• Role Specialists: Policy officers, legislative drafters, economists, lawyers, comitology officials, grant managers, communication officers, analysts. These handle the technical work — producing reports, legal frameworks, data syntheses, and options papers.
• DG Operational Agents (17 profiles): Simulate the technical and operational constraints of specific Directorates-General. DG COMP doesn't hold political opinions — it produces competition analysis with attribution labels like [DG COMP analysis shows...].
• Counterpart Institutions: European Parliament, Council, ECJ, ECB, EEAS, European Council. These simulate inter-institutional dynamics during Trilogue, codecision, and other cross-institution procedures.

Inline Attribution — How It Actually Works

The lib/hooks/ directory is the beating heart of Montoyer's trust infrastructure. When an agent produces text, a chain of shell scripts processes it in real-time:

1. Pre-generation: pre-legal-basis-check.sh runs first, validating the legal basis before generation begins
2. During generation: post_tool_use_citation_matcher.sh and post_tool_use_eurlex_resolver.sh intercept the stream, match citations against the local Treaty schema, and resolve EUR-Lex references against live Curia data
3. Post-generation: post-output-disclaimer.sh appends the DRAFT disclaimer; post-subsidiarity-prompt.sh adds subsidiarity principle checks

The result is text where every legal claim carries a visible trust tag — not as a cosmetic badge, but as a traceable reference to the source it came from.

LLM-Agnostic by Design

Montoyer's core logic lives in structured file systems, regex routers, and local knowledge schemas — not in model weights or third-party orchestration frameworks. There's no LangChain dependency. No CrewAI pipeline. The framework is optimized for Claude Code runtime, but the underlying architecture doesn't lock you into any specific LLM.

This matters for two reasons:

1. Vendor independence: If a better model comes along, you swap it in without rewriting the framework
2. Auditability: The logic that routes a /treaty-check command to a legal-basis validator lives in readable Markdown and shell scripts, not in a black-box model call

Legislative Cycle Simulation — End-to-End

The /legislative-cycle command is Montoyer's flagship multi-agent orchestration. It runs a complete sequence:

1. /policy-officer generates a policy brief from your input
2. Brief routes through /inter-service-consultation to affected DGs and Legal Service
3. /college-deliberation simulates political validation by all 21 Commissioners
4. /trilogue negotiation with simulated Parliament and Council positions
5. Final text generation with full compliance checks and attribution tags

Each step produces artifacts (minutes, opinions, amendments, revised texts) that would be recognizable to any Commission insider.

---

Ecosystem & Integrations

Montoyer isn't just a codebase — it's a community-built ecosystem that's growing organically around the EU quarter.

Open-Source Community

The entire Montoyer framework lives on GitHub under the MIT License — no restrictions, no dual licensing, no "open core" bait-and-switch. The community repository at github.com/montoyer/agents contains:

• All 8 domain plugins with their full skill sets
• Knowledge base files for all 21 Commissioners, 17 DGs, and counterpart institutions
• The complete hook chain for the Inline Attribution Architecture
• Template files (_template.md) for creating new agents, skills, and plugins

The project is actively welcoming contributors, with a clear CONTRIBUTING.md guide that walks through the process from setting up your environment to submitting a PR.

Plugin Ecosystem — Built for Extensibility

Montoyer's plugin system is designed so that anyone can extend it. Each plugin package follows a standard directory structure:

plugins/[domain]/
├── CLAUDE.md              # Domain practice file
├── .claude-plugin/
│   └── plugin.json        # Plugin manifest
├── skills/
│   └── [skill-name]/
│       └── SKILL.md       # Skill definition
├── references/            # Domain reference documents
└── hooks/                 # Domain-specific hook scripts

The marketplace.json registry makes plugins discoverable and installable. Currently 8 plugins are registered, but the community can — and is encouraged to — add more. The EU policy domain is vast (competition, trade, agriculture, health, energy, transport, digital, environment, justice, home affairs, and more), and no single team can cover it all.

How to Contribute

Building a skill for Montoyer is simpler than you might expect:

1. Clone the repo and check the file map to understand the structure
2. Create a skill directory under plugins/[domain]/skills/[skill-name]/
3. Write your SKILL.md following the template format — name, description, triggers, role, scope, output format, and step-by-step workflow with MUST DO / MUST NOT DO constraints
4. Test it against the framework to ensure it integrates properly
5. Submit a PR to the GitHub repository

The community is particularly interested in skills that expand geographic coverage (e.g., member state transposition tracking), add new policy domains (e.g., health security, migration), or improve existing simulation fidelity.

Platform Recognition

Montoyer has been listed on 12+ AI tools directories and product discovery platforms, giving it visibility across multiple communities:

AI Agents Directory, Shipit, Wired Business, Startup Fame, Findly.tools, Twelve Tools, Turbo0, Verified Tools, Dofollow.Tools, Similarlabs, Dang.ai, DailyPings

Content & Thought Leadership

The Montoyer Substack blog has become a space for deeper conversations about AI agents and EU institutions. Published pieces include:

• "Montoyer launches AI agents for the EU quarter" — the product announcement and vision
• "Shuhari, AI agents, and the European Commission" — exploring how the Japanese martial arts concept of Shuhari (守破離) maps onto the stages of AI agent maturity in institutional settings

These aren't marketing materials. They're genuine explorations of what it means to build AI systems that understand and respect the complexity of democratic institutions.

---

Frequently Asked Questions