More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    The Agents Council

    1

    Forge ideas, challenge decisions, and verify implementation with specialist agents and a local Rust core.

    $4.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    The Agents Council

    The Agents Council

    Example session with this skill installed

    Launch a Council review for the proposed migration from REST to gRPC for the internal logging service. Use the default panel and provide a build/revise recommendation.

    • Read your context and instructions
    • Compiled the the agents council

    The Council has completed the architectural review of the REST to gRPC migration proposal. Six specialized agents (Ada, Grace, Hypatia, Florence, Turing, and Seymour) evaluated the evidence across five dimensions.

    Council Decision: REVISE

    AgentArchitectureReliabilityGovernancePerformanceProductStatus
    Ada (Arch)87797PASS
    Grace (Rel)65786BLOCK
    Hypatia (Gov)77877PASS
    Turing (Perf)98797PASS
    Seymour (Con)56685DISSENT

    Weighted Alignment Score: 6.8 / 10
    Population Spread: 1.42 (Exceeds 1.25 threshold)

    Findings and Blockers

    Reliability (Grace): Identified a critical lack of evidence regarding retry logic and load balancer compatibility during the cutover phase.

    Contrarian View (Seymour): Noted that the added serialization overhead for small log payloads may negate gRPC performance gains.

    Performance (Turing): Confirmed 40% throughput increase in synthetic benchmarks, but notes this is contingent on HTTP/2 multiplexing stability.

    Verification Status

    • Browser Evidence (Bob): UNKNOWN (No browser-based load tests provided)
    • Implementation Status: NOT ELIGIBLE (Due to active scope blockers)

    Next steps

    1. Address the reliability blocker by documenting the gRPC retry policy and envoy configuration.
    2. Run a comparative benchmark for small payload sizes to resolve Seymour's performance dissent.
    3. Re-invoke council with updated evidence for a second compact round.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    FREE REQUIRED RUNTIME — github.com/ercoledevs/the-council-runtime

    Install the free macOS/Linux companion once. No Rust compiler, GitHub account or source access is required. The skill purchase covers the workflows; the runtime is freely downloadable by everyone.

    The Council gives your coding agent a complete path from a promising idea to a reviewed decision and verified implementation.

    Forge brings together five specialized creators to shape a buildable proposal. It preserves constraints, checks numerical convergence, records each round and targets unresolved divergence. Council challenges the proposal through architecture, reliability, security, product, contrarian and performance perspectives, with anonymous peer review, accuracy ceilings and visible dissent. Mind connects creation and judgment, then hands the unchanged approved scope to Hyper when implementation is authorized.

    Hyper uses the smallest justified execution plan: bounded read-only investigation, one implementation writer and fresh independent falsification when required. Every required check stays visible as PASS, FAIL or UNKNOWN. A blocker cannot disappear inside a high average score.

    Tune seven named roles with Alters while preserving evidence and safety requirements. Add Leonardo for a dedicated UX critique and Bob for actual browser scenarios. Bob never votes; missing browser evidence remains unknown.

    The local Rust core provides deterministic scoring, persistent Forge rounds, scope and source checks, estimates, profiles, statistics and private history. Its Decision Runtime projects legacy evidence into typed Cells and a frontier view, compares their semantics, plans advisory impact, applies append-only patches and supports replay, explicit recovery, rollback and retention. It never changes the Council verdict or dispatches agents on its own.

    Designed for Codex, Claude Code and Cursor, using the host's models and tools. The runtime targets macOS and Linux and is required for the complete feature set. Install it separately from the supplied companion source or a creator-provided release. No extra model-provider key is required by The Council. Host model and tool usage still consumes your existing allowance.

    Use it for consequential architecture decisions, complex changes, reusable skills, frontend interactions and ideas that need a disciplined route into tested code. Ordinary small edits can stay small. Your agent thinks. Rust checks the contract.

    Key features

    • Complete named workflows: Forge, Council, Mind, Hyper, Alters, Leonardo/Bob and Decision Runtime in one progressively loaded skill.
    • Five-creator Forge: bounded rounds, separate synthesis, alignment/spread gates, preserved dissent and a three-round ceiling.
    • Evidence-led review: six core lenses, a dedicated skill-review panel, risk-aware routing and the original five-dimension Council rubric.
    • Scope-bound implementation: explicit handoffs, source fingerprints, one writer and fresh verification when required; verified edits and deletions are supported.
    • Practical frontend gates: UX dissent, exact browser cases, observable interactions, saved artifact digests and zero Bob votes.
    • Local analytics: transparent estimates, optional sourced credit rates, consented history calibration, dashboards and path-only audit bundles.
    • Recoverable shadow state: private immutable generations, stale-write protection, typed patches, frontier comparison, replay and explicit recovery/retention.
    • Legacy evidence import: preserve original session bytes, historical prompts and browser evidence while creating a separate native session.

    Requirements and compatibility

    The host must load the entrypoint and all required supporting references, expose a terminal for the Rust companion and provide the target project's tools. Independent review requires isolated agents; persona labels alone are insufficient. The host concurrency limit determines wave size. Required cold verification blocks completion when isolation is unavailable. Browser acceptance requires actual browser tools and a runnable target.

    The full feature set requires the-council 0.2 or later on macOS/Linux. The companion source is included separately in this creator kit; a stable Rust/Cargo toolchain builds it. The first build downloads pinned dependencies. The Agensi upload itself contains text instructions and examples, with no native executable. Agensi's reference loader and the creator's permitted companion-delivery channel must both be checked before selling the full workflow.

    Codex, Claude Code and Cursor are intended hosts. Local format/CLI validation is distinct from a live test in each product version or Agensi marketplace approval. See the release verification record for executed tests. Token estimates are local heuristics, not billing telemetry or account limits.

    Example prompts

    1. “Use The Council Forge to design a local job queue. Keep the API small, bound memory, and make rollback explicit.”
    2. “Use The Council to review this migration for data loss, privacy, operational failure and rollback. Preserve every blocker and dissent.”
    3. “Use The Council Mind to shape this idea, judge it and implement the unchanged scope I authorize once its gates pass.”
    4. “Use The Council Hyper to fix this concurrency defect. Keep one writer, run the regression and obtain a fresh verifier.”
    5. “Use The Council with Leonardo and Bob for this modal flow. Verify keyboard focus, background interception, Escape and mobile controls.”
    6. “Preview an Ada alter focused on Rust service boundaries. Keep all Council gates intact; show the compiled tuning before saving.”
    7. “Project this completed session into Decision Runtime, compare the frontier representation, and show the advisory impact of this typed patch.”

    Expected output

    Council returns build, revise or stop, with confidence, capability limits, evidence-backed blockers, refinements, dissent and verification. Forge returns a proposal and explicit convergence result. Mind separates creative dissent, review judgment and implementation evidence. Hyper completion includes acceptance/check results, falsification, rollback and residual risks. Rust validates supplied records; it does not authenticate that the host executed a command or obtained human consent.

    Requires local Rust core for deterministic scoring. convergence requires alignment 7+ and spread under 1.25. Implementation requires explicit authorization and available verification tools.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The Council uses a local Rust core to manage isolated agent 'waves' that debate proposals using a weighted rubric, ensuring decisions are based on structured scoring rather than simple text generation.

    You will receive the proprietary local Rust CLI core (`the-council`), the full agent persona library, and the OODA-based execution contracts for verified implementation.

    The skill is designed to work within terminal environments and integrates with browser automation tools; however, the local Rust core must be installed to handle state management and deterministic scoring.

    The 'Hyper' mode utilizes an independent read-only verifier that must confirm command outputs and system states before a task is marked as complete, preventing the agent from hallucinating its own success.

    Yes, while it comes with five standard personas, you can tune agent rigor, risk posture, and the five-dimension rubric to match your organization’s specific governance requirements.

    No. The host supplies its agents and models. Role diversity does not imply multi-vendor independence.

    New in Agents & Orchestration