multi-agent-architect

Designs contract-first multi-agent architectures with generator-evaluator separation and test-gated integration.

3|1|Updated Nov 30, 2025
One-click install
npx skills add https://github.com/PALabs-v1/AI_friend --skill multi-agent-architect-palabs-v1
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: multi-agent-architect
Source: https://github.com/PALabs-v1/AI_friend/tree/main/skills/sovereign-mesh-architect
Command: npx skills add https://github.com/PALabs-v1/AI_friend --skill multi-agent-architect-palabs-v1

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Building and evolving a multi-agent system without a disciplined protocol leads to coupled modules, silent contract drift, and regressions that corrupt latency targets and identity continuity. This Skill enforces a contract-first, test-gated development protocol so every architectural change starts from Pydantic interface schemas and passes evaluator gates before integration. ## Core Features & Use Cases - Contract-First Development: All inter-agent communication is defined as Pydantic schemas in a single source-of-truth contracts module, with versioned contract amendments. - Parallel Codegen Orchestration: Designs generator/evaluator/integrator role separation so parallel sub-agents build decomposable artifacts (compilers, parsers, runtimes) with sealed modules and checkpoint-resumable runs. - Local-First Voice and Memory Architecture: Provides specialized architect personas for on-device voice I/O (TTS/STT engine routing, voice profiles, dictation) and verbatim local memory systems with hierarchical indexing and benchmark-driven recall. - Use Case: When adding a new agent to the mesh, use this Skill to define its interface contract, assign generator and evaluator sub-agents, gate integration on regression tests, and record the change in the Agent Context Ledger. ## Quick Start Ask the architect to decompose a new compiler-like artifact into modules with interface contracts, test gates, and a phased generator-evaluator integration plan.

Frequently Asked Questions about multi-agent-architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I coordinate parallel LLM agents to build a single software artifact?

Decompose the artifact into modules with testable interfaces, then assign one orchestrator, one generator per module, and independent evaluators that gate each module on passing tests. Generators never see each other's transcripts; the orchestrator reads only summaries and verdicts.

What is contract-first development for multi-agent systems?

Contract-first development defines all inter-agent communication as Pydantic schemas in a single contracts module before any implementation begins. No module crosses the integration boundary until it passes an evaluator gate of regression tests against those contracts.

When should I not use parallel codegen with sub-agents?

Avoid parallel codegen when the artifact lacks natural module boundaries, when correctness cannot be judged by external tests, or when per-module work is too small to repay coordination cost. In those cases use a single autonomous coder or managed brain/hands pattern.

Can a generator agent also evaluate its own code?

No. The protocol forbids one agent playing two roles; a generator that evaluates its own work is just a single-agent coder with extra steps. Evaluators are read-only on code and tests and issue only PASS, FAIL, or NEEDS REVISION verdicts.

How does local-first agent memory avoid the summarize-and-pray problem?

It stores original user and assistant text verbatim in a hierarchical index of wings, rooms, and drawers, retrieving via local embeddings with no LLM in the base recall path. Summaries exist only as derived views and never replace the raw source.

What happens when a parallel codegen run is interrupted?

Each module's contract, tests, sealed implementation, verdict, and summary are checkpointed after every seal. A killed run resumes from the last seal without re-running generators on already-sealed modules.