GuildControl MCP field comparison
This evidence snapshot was audited on 2026-08-29 against the latest Discord matches returned by the official MCP Registry search API. It compares the repository revision containing this page with released competitors whose source and execution model are sufficiently visible to assess. GuildControl MCP leads every operator outcome in the release-scored matrix. Focused source-head comparisons remain outside that versioned score and explicitly preserve narrower competitor leads as product gaps.
The claim is deliberately narrow. It means the public evidence in the release-scored matrix demonstrates a materially stronger complete outcome in every row. It does not mean every competing project is intended for the same use case, lacks useful ideas, or has no unexamined capability. A missing public control is recorded as Not demonstrated, never as proof that the control is absent.
How to read the matrix
Section titled “How to read the matrix”- Lead: the strongest complete public evidence for the defined operator outcome
- Covered: the complete narrow criterion is demonstrated, but another implementation demonstrates a materially stronger outcome
- Partial: useful parts are demonstrated, but one or more material parts of the criterion are not
- Not demonstrated: the audited release provides no public evidence sufficient to make the claim
- Different fit: the product deliberately does not pursue this outcome
- Not auditable: the registered implementation or exact released source is not publicly available
Statuses are evidence classifications, not numerical grades. The rubric was selected before scoring and reflects qualities an operator must depend on: useful coverage, bounded authority, safe changes, recoverable failure, transparent custody, setup success, and independently inspectable evidence.
Head-to-head matrix
Section titled “Head-to-head matrix”GuildControl MCP is the only implementation classified as Lead in every row. Each lead links to the durable project contract and the strongest released competing evidence below, so the matrix is a falsifiable comparison rather than a feature-count claim.
| Operator outcome | GuildControl MCP | Cappyeo | PaSympa | Hypark | Oratorian | Jaimen Bell | Targeted Reader |
|---|---|---|---|---|---|---|---|
| Capability breadth and release-exact contract inspection | Lead | Covered | Partial | Partial | Partial | Partial | Partial |
| Transparent access lifecycle and target-bound authorization | Lead | Covered | Partial | Partial | Not demonstrated | Partial | Not demonstrated |
| Complete machine-readable setup requirements and live-readiness boundary | Lead | Covered | Not demonstrated | Partial | Not demonstrated | Partial | Not demonstrated |
| Deterministic channel placement and safe reparenting | Lead | Partial | Partial | Not demonstrated | Partial | Not demonstrated | Not demonstrated |
| Reviewed parent-category permission synchronization | Lead | Partial | Not demonstrated | Not demonstrated | Partial | Not demonstrated | Not demonstrated |
| Least-privilege policy and exact operator scope | Lead | Partial | Partial | Covered | Not demonstrated | Partial | Not demonstrated |
| Credential custody and pinned application identity | Lead | Covered | Partial | Partial | Partial | Partial | Partial |
| Complete privacy-safe bot-installation drift detection | Lead | Partial | Partial | Not demonstrated | Partial | Not demonstrated | Not demonstrated |
| Application-owned Activity session verification | Lead | Covered | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Privacy-minimized reads and non-persistence | Lead | Partial | Partial | Covered | Partial | Partial | Not demonstrated |
| Caller-retained multi-channel message catch-up with loss-resistant coverage | Lead | Partial | Partial | Partial | Partial | Not demonstrated | Partial |
| Live vague-memory conversation recall with fresh context | Lead | Partial | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Safe message writes, mentions, and duplicate prevention | Lead | Partial | Partial | Covered | Partial | Partial | Not demonstrated |
| Human-visible exact-message and directed-note coordination with bounded inspection | Lead | Partial | Partial | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Typed local Components V2 template authoring and reviewed publication | Lead | Covered | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Guarded soundboard playback with exact readiness and replay safety | Lead | Covered | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Token-private native Interaction response lifecycle | Lead | Partial | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Authenticated request-button publication and private ingress | Lead | Partial | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Guarded writes and fresh review for high-impact mutations | Lead | Partial | Partial | Partial | Not demonstrated | Partial | Not demonstrated |
| Destructive and administrative safeguards | Lead | Partial | Partial | Partial | Not demonstrated | Partial | Not demonstrated |
| Target-bound recovery preparation before irreversible retirement | Lead | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Ambiguous failure handling and restart-safe recovery | Lead | Covered | Partial | Partial | Not demonstrated | Partial | Not demonstrated |
| Setup, diagnostics, and read-only first success | Lead | Covered | Partial | Covered | Partial | Partial | Not demonstrated |
| Reviewed static host-configuration installation, drift inspection, and recovery | Lead | Partial | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Release-exact migration and safe switching ergonomics | Lead | Partial | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| MCP-native discovery, resources, prompts, and review UX | Lead | Covered | Partial | Covered | Partial | Partial | Partial |
| Optional real-time behavior with privacy bounds | Lead | Covered | Partial | Different fit | Partial | Different fit | Different fit |
| Content-free audit and privacy-safe observability | Lead | Covered | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated | Not demonstrated |
| Reproducible distribution and supply-chain evidence | Lead | Covered | Partial | Covered | Partial | Partial | Not demonstrated |
| Searchable, verifiable, privacy-preserving documentation | Lead | Covered | Partial | Covered | Partial | Covered | Not demonstrated |
| Automated product, security, package, and documentation verification | Lead | Covered | Partial | Covered | Partial | Partial | Not demonstrated |
Why each lead is material
Section titled “Why each lead is material”| Outcome | GuildControl MCP evidence | Strongest competing evidence and remaining gap |
|---|---|---|
| Capability breadth and contract inspection | The complete reference spans broad typed Discord reads and reviewed administration, including the authenticated current-bot profile lifecycle. The credential-free catalog exercises the production registration path and emits deterministic tools, schemas, annotations, prompts, resources, templates, completion bindings, review-app evidence, risk accounting, and digests without a token or Discord call. | Cappyeo publishes a broad typed catalog and progressive surface in its released server registration, but does not publish an equally complete release-exact protocol evidence report covering prompts, completion bindings, review UX, and the execution guard. TheETR's useful unregistered current-bot profile operation is compared separately below because it has no immutable release tag. |
| Access lifecycle and authorization | The machine-readable tool access contract classifies every exact tool as local, live read, reviewed plan, reviewed execution, receipt verification, or guarded write; names complete workflow companions; appears in policy-aware discovery, a budget-safe static MCP index with exact per-tool resources, offline doctor, deterministic JSON evidence, and the standalone explorer; and explicitly grants no authority. Every external operation evaluates its applicable target-specific identity, local scope, Discord permission, hierarchy, intent, and freshness requirements, while reviewed execution additionally binds signed approval to a fresh matching plan and exact readback. | Cappyeo 0.25.0 adds an excellent machine-readable permission and intent registry, targeted doctor access report, and optional runtime access gate. Its runtime mode defaults to advisory, several routes delegate verification, and its registry does not bind operation-wide lifecycle classification to exact reviewed companions, final freshness, durable coordination, and readback evidence. |
| Static setup requirements and live readiness | The complete static readiness contract gives every canonical tool a deterministic authentication class, target boundary, connector policy inputs, baseline and conditional Discord permissions, privileged and nonprivileged Gateway intents, hierarchy mode, curated preset or recipe links, and runtime-verification boundary. Exact-tool and conservative toolset sources remain explicit, aggregate coverage has no unknown entries, progressive discovery returns the same record, and the credential-free index, exact per-tool resources, local tool-name completion, and searchable explorer make the contract independently inspectable without granting or claiming authority. | Cappyeo provides the strongest released baseline through its permission and intent registry and coverage audit. The source describes a conservative catalogued subset, deliberately reports absent entries as unknown, and does not connect every tool to local policy inputs, curated least-privilege setup, credential custody, complete access lifecycle, or one explicit live-readiness boundary. Hypark and Jaimen Bell document useful installation permissions and intents, but their audited releases do not expose an equivalent complete per-tool machine contract. |
| Channel placement and safe reparenting | Reviewed channel placement uses one exact target and anchor for deterministic above-or-below placement within or across categories. A cross-parent plan verifies complete topology, both affected groups, source and destination authority, exact target visibility and authority, category capacity, and permission-overwrite preservation; execution sends one no-sync non-retried payload and requires complete Gateway plus coherent HTTP readback. | Cappyeo exposes immediate raw parent_id mutation in its released channel modifier, PaSympa exposes an immediate category change in its released channel tools, and Oratorian accepts a direct parent edit in its released channel tool. These are useful outcomes, but none demonstrates the same target-and-anchor deterministic plan, dual authority and capacity proof, explicit overwrite preservation, signed review, durable one-shot coordination, two-source readback, and ambiguity quarantine. |
| Parent-category permission synchronization | Reviewed parent-category permission synchronization replaces one exact direct child's complete overwrite set only after independent scope, complete structural delta review, protected-member checks, current, parent, and prospective authority proof, explicit replacement, propagation, and quiescence acknowledgments, signed review, durable child-and-parent coordination, one non-retried write, exact response validation, fresh synchronized-state readback, and ambiguity quarantine. | Oratorian provides the strongest direct feature with one channel ID and discord.js lockPermissions() in its released channel tool. Cappyeo exposes the lower-level complete permission_overwrites array through its released generic channel modifier. Neither demonstrates the same exact child policy, complete before-and-after evidence, protected-member and connector continuity boundaries, consequence acknowledgments, signed fresh plan, durable one-shot record, non-retry contract, exact independent readback, or recovery model. |
| Least-privilege policy and exact scope | The configuration contract binds exact read scopes, risk-separated toolsets, independent capability toggles and write allowlists in one strict versioned non-secret file. Portable profiles can narrow but never widen it. | Hypark has strong write-off defaults plus guild and channel allowlists in released configuration, but it has no equivalent independent read scopes, capability-specific allowlists, pinned identity, or profile non-escalation boundary. Cappyeo's released configuration defaults to the full tool surface, all guilds, advisory access checks, advisory DM consent, and immediate non-destructive writes. |
| Credential custody and identity | The credential and application posture requirements keep the token outside portable policy and bind operation to verified application and bot IDs before protected reads or writes. Setup, doctor, host activation, and profile flows preserve that separation. | Cappyeo supports an optional expected bot ID and secret-aware launcher diagnostics in its released configuration, but application identity is not pinned and bot binding is optional. Other audited local releases accept a bot token without an equivalent required application-and-bot binding. |
| Bot-installation drift | The complete bot-installation audit pins application and bot identity, enumerates fixed ID-only pages to a proved terminator, rejects partial or malformed evidence under response and total bounds, classifies exact configured, installed, in-scope, missing, and unexpected IDs, and exposes the same result through setup, doctor, smoke, status, a tool, a resource, and a prompt without metadata, persistence, policy mutation, or departure. | Cappyeo provides the strongest released baseline: its setup discovery paginates installed guilds and validates an allowlist, while its runtime guild-list tool exposes caller-controlled pages. The release does not demonstrate one post-setup complete expected-versus-installed drift result, required application identity, ID-only projection, a hard total bound, or consistent status, doctor, smoke, resource, and prompt surfaces. |
| Application-owned Activity session verification | Activity-instance verification binds one opaque instance to the pinned application, verified bot, exact expected readable guild channel, strict response identity and location, count-only participants, and optional exact-user membership while rejecting private locations and persisting nothing. | Cappyeo supplies the strongest competing operation in its released Activity-instance tool. It accepts a caller-selected application ID and returns the raw location object and complete participant ID array without an expected guild-channel scope, pinned application proof, private-location refusal, or minimized participant projection. |
| Privacy-minimized reads and non-persistence | The MCP result boundary returns purpose-built projections, marks Discord text as untrusted, bounds results, and excludes Discord content and display data from durable records. | Hypark states that it does not independently persist Discord results in its privacy policy, but its released result projection returns message content, usernames, mentions, guild names, and profile fields. Cappyeo explicitly permits raw Discord data in structured results in its released server instructions. |
| Caller-retained multi-channel message catch-up | Multi-channel catch-up preflights every exact selected channel before message reads, returns compact chronological previews and independent caller-held next cursors, advances across default-hidden automated traffic, and independently verifies the oldest boundary before advancing a full forward page. It persists no content, profile, cursor, inbox, or partial result and includes a one-shot prompt with machine-copyable continuation state. | Cappyeo's released messages_read provides a useful exact single-channel after cursor with oldest and newest IDs, but returns raw content and profile names and does not provide one all-channel-preflighted call, independent cursor map, automated-message coverage, full-page boundary proof, or catch-up guidance. The strongest direct source-head idea comes from cael-agent and is compared separately below because it is not part of the release-scored Registry set. |
| Live vague-memory conversation recall | Live conversation recall runs one to five exact-scope literal variants through Discord's official relevance index, fuses duplicates, stops without partial evidence on indexing, and freshly binds every ranked target to bounded current context before returning names-free, phrase-redacted evidence without connector-owned persistence. The policy-completable recall_discord_conversation prompt provides the complete one-call workflow. | The strongest direct idea comes from blackgirlbytes' unregistered live multi-phrase recall service, which introduced phrase-coverage plus reciprocal-rank fusion and a separate context reader. Its live result echoes the memory, every phrase, channel names, and user presentation; context is a second unbound call; identity and exact local scope are not pinned; and its broader analytics workflow stores Discord content and membership metadata in unencrypted SQLite. Cappyeo's released recent-message search scans one recent channel page for one substring and does not demonstrate multi-phrase guild recall, fused relevance, or fresh target-bound context. |
| Safe message writes | The least-privilege message-channel recipe exposes only plain-text send, reply, connector-owned edit, and bounded typing acknowledgement in exact channels, with no privileged intent or unrelated read, reaction, component, embed, or coordination tool. Actual sends and edits use ordinary host write approval rather than per-message signed confirmation, then enforce mention policy, anti-spam controls, Discord nonce uniqueness, local idempotent replay, content-free receipts, exact authorship, and fresh readback. | Hypark is the strongest narrow implementation: its released REST client suppresses mentions and enforces a random nonce, and its server limits edits and deletion to bot-authored messages. It still groups read and write exposure behind broader flags and executes without the same recipe-level tool isolation, host approval contract, local replay convergence, content-free lifecycle evidence, or exact postcondition checks. |
| Discord-native task coordination | The coordination contract combines a static model-neutral lifecycle, random caller-retained spoofable routing labels, strict versioned directed or broadcast notes, body-free bounded address observation, filtered recipient reads, exact caller-held cursors, aggregate-safe reaction conventions, two one-shot inspection prompts, guarded idempotent publication, reviewed threads and native polls, explicit untrusted-content treatment, and no connector-owned registry, task persistence, listener, or polling loop. | PaSympa's released message suite provides explicit reply writes, reactions, and message-anchored threads, while Cappyeo's released catalog separately provides message sends, reaction reads, and thread creation. Neither release demonstrates one directed or exact-task lifecycle, opaque authority-free routing, bounded body-free sender discovery, strict recipient collector, caller-held coverage cursor, aggregate-default status convention, idempotent guarded publication, MCP-native guidance, or explicit no-registry, no-persistence, and no-polling boundary. |
| Typed local component templates | Typed local templates compile five strict semantic requests into the existing bounded static Components V2 DSL, including optional strict link CTAs for announcements and release notes. Compilation normalizes exact destinations, exposes a versioned data-free catalog and complete transient link and notification review, and hands the result to the full exact-origin-scoped publication and receipt-verification lifecycle without Discord contact, template persistence, or send authority. | Cappyeo supplies the strongest released template baseline with five bundled template definitions and a payload-confirmed send-from-template tool. Its one generic string map supplies caller-computed poll presentation, winner state, URLs, media, and custom IDs, and the tool proceeds to a message POST after its shared approval. The release does not demonstrate per-template semantic schemas, local compile-only output, derived totals or state styling, exact normalized link and origin review, an independent exact-origin policy enforced before Discord access, connector-fetch and redirect boundaries, exact notification projection, target-bound plan evidence, durable operation recovery, independent readback, or a static catalog resource for this outcome. |
| Guarded soundboard playback | Exact-scope playback independently gates exact target voice channels and custom-sound source guilds, proves pinned identity, complete permissions, current bot voice state, and exact sound availability, then combines a request-bound one-shot key, durable channel coordination, shared anti-spam controls, pending content-free evidence, one non-retried request, strict REST success, optional exact Gateway corroboration, local replay, and ambiguity quarantine. | Cappyeo provides the strongest released baseline with a clean typed soundboard send tool and conditional permission registry. It documents the voice connection as a prerequisite and sends immediately, but does not demonstrate an independent exact target-channel or source-guild policy, pinned application identity, fresh channel type, current voice-state and sound-availability proof, request-bound durable replay, cross-process channel exclusion, shared anti-spam control, pending content-free record, exact Gateway corroboration, or ambiguity quarantine for this action. |
| Token-private native Interaction lifecycle | Native Discord Interaction ingress verifies exact application, bot, guild installation, command, channel, and user evidence before exposing a request; keeps the Discord token broker-private; discards it by default; and retains it only behind an explicit rotating one-shot continuation with shared capacity, fixed lifetime and sequence, ephemeral mention-free content, pending activity, one non-retried write, exact direct response, independent readback, and ambiguity quarantine. | Cappyeo publishes useful original-response and follow-up CRUD, including follow-up creation, but requires the reusable interaction_token in MCP input and permits caller-selected rich payload and mention fields. Its guild-allowlist middleware explicitly classifies every opaque-token Interaction tool as guild-scope blocked because target guild cannot be proven before execution. The release does not demonstrate an end-to-end token-custody broker, exact ingress binding, rotating constrained capability, content-free pending record, exact readback, or uncertainty quarantine. |
| Authenticated request-button lifecycle | Managed request Buttons add one typed label-and-style request row to the existing reviewed Components V2 lifecycle. Planning and final replanning freshly verify the complete managed-command inventory and bind the exact authorized user IDs, command identity, and version. Publication generates HMAC IDs bound to application, bot, guild, channel, layout, one-shot key, index, label, and style, then proves exact response plus readback. A click is admitted only after exact user scope, attached-message authentication, a fresh source-message GET, and another fresh command inventory; it creates one private bounded token-free request and no automatic Discord mutation. | Cappyeo exposes useful styles 1 through 4 with caller-supplied custom_id in its released Components V2 schema and sends the raw reviewed array through components_v2_send. Its released Gateway client binds guild, voice, typing, presence, and audit-resource handlers but no Interaction event handler, while its response tool requires the caller to supply the raw Interaction token. The release does not demonstrate a published-ID authenticity contract, exact source-message or user binding, fresh click evidence, token-private request broker, replay and capacity boundary, content-free click record, or source-specific response readback. |
| Guarded writes and high-impact review | Interactive plan review is a common product primitive for high-impact mutations: fresh keyed plan evidence, signed request state, MCP host write approval, interactive confirmation, final freshness checks, and a pending content-free record all precede execution. Lower-risk idempotent interactions remain visibly classified as guarded writes and retain host approval plus operation-specific policy, target, permission, anti-spam, recovery, and verification gates. | Cappyeo 0.25.0 adds strong one-time payload-bound component approval, opt-in recipient-bound DM approval, and an optional durable HMAC-protected approval ledger. Its released defaults and write middleware still allow ordinary non-destructive writes immediately, and its broader destructive confirmation remains a caller-provided boolean rather than fresh signed reviewed state. |
| Destructive and administrative safeguards | The deletion workflow, member moderation workflow, and other reviewed lifecycles add exact IDs, action-specific permission and hierarchy proof, protected-target denial, freshness, signed confirmation, durable reservation, and exact readback. | PaSympa provides default dry runs for selected mass operations and channel deletion in its released tools, while other destructive operations execute directly. Hypark requires a separate delete flag and confirm: true in its released server, but does not create a target-bound reviewed plan or recheck fresh state. |
| Target-bound recovery preparation | The caller-retained recovery contract requires every channel or role retirement to choose either a stable captured structural artifact with an exact signed target binding or an explicit no-artifact acknowledgement. A verified binding expires after 30 minutes, is process-bound, matches the pinned application, bot, guild, target kind and ID, and fresh captured target projection, carries exact omission and limitation evidence, and enters the deletion plan and signed confirmation only through its hash and credential-free projection. The connector never stores the artifact or attestation and never presents either as rollback authority. | TheStreamCode supplies the strongest adjacent source-head design: its deletion guard requires a backup ID or explicit allowWithoutBackup, and its backup tools support conservative restore. The guard validates the backup filename and source guild, but does not demonstrate exact target binding, current target-state proof, short-lived process binding, or signed plan integration. Its stored backup schema deliberately persists names, topics, permissions, AutoMod policy, scheduled-event presentation, and other server state. Automatic lossy restore is a useful different outcome that GuildControl MCP intentionally does not claim. |
| Ambiguous failure and recovery | Durable reviewed-write coordination reserves each operation, never retries ambiguous mutations, quarantines uncertain outcomes, supports explicit reconciliation, and resumes bounded multi-step work from content-free checkpoints. | Cappyeo has strong non-idempotent retry classification in its released REST resilience layer and restart-safe checkpoints for its blueprint workflow. Equivalent durable coordination and ambiguity quarantine are not demonstrated across its ordinary mutation catalog. |
| Setup and diagnostics | The getting-started guide leads to a verified read before writes. A compatible host can import one deterministic MCPB for macOS, Windows, or Linux, select the complete strict policy, and provide only the bot token through a sensitive prompt. The operator CLI adds environment- and dependency-free root, family, and exact-action help; strict config creation and validation; complete selected-tool lifecycle diagnostics; offline and online doctor checks; read-only smoke; and one credential-free activation digest projected into deterministic common MCP JSON, Cursor, VS Code, and Gemini CLI adapters for hosts or credential policies outside the bundle contract. | Cappyeo sets a strong command and client-coverage bar with a Commander-based CLI whose grouped profile actions receive native contextual help, released generators for several editors and CLIs, and selected config audits. Hypark ships a Cursor link, Gemini extension, exact client guide, and a real MCPB; PaSympa documents VS Code secure input. GuildControl MCP combines that one-click outcome with exact action-level authority and side-effect help, a third desktop platform, one non-secret policy source instead of duplicated authority toggles, isolated exact-variable secret mapping, deterministic archive proof, an unpacked MCP handshake, and policy-bound adapter fallbacks. |
| Host-configuration installation, drift, and recovery | The reviewed host installer plans fixed owned-record changes without returning the selected path, values, unrelated state, or a stable private-byte hash, binds freshness to the exact release activation, adapter, target identity, and metadata, preserves unrelated shared JSON, refuses ambiguity, requires exact digest and confirmation, retains a recoverable owner-mode backup, publishes atomically, rereads exactly, and rolls back on failed verification. The separate read-only inspector covers every supported adapter with fixed path- and value-free drift evidence before runtime proof moves to smoke. | Cappyeo provides the strongest released setup breadth through its client generators, but its own snippet contract says the documented client path is not auto-written, while init --output writes the standalone snippet and uses --force to permit replacement rather than merging a live shared document. Its dry-run-first launcher update command handles one generated launcher through npm's mutable latest tag. The release does not demonstrate a multi-adapter owned-record merge with selected-policy activation binding, path- and value-free planning, strict private-file freshness, unrelated-state preservation, backup, exact reread, rollback, separate drift inspection, and staged MCP plus Discord verification. |
| Migration and safe switching | The release-exact migration planner accounts for every public tool in every scored peer release, preserves tagged versus version-matching audit fidelity, maps complete operator outcomes into validated target tools, presets, recipes, and reviewed lifecycles, and binds deterministic JSON plus a private interactive guide to source, manifest, migration-catalog, and negotiated target-contract digests. It reads no checkout, source configuration, host setting, environment value, credential, network, or Discord endpoint and changes nothing. | Cappyeo introduced the strongest released migration baseline with an adapter-based migration command that scans a caller-selected source checkout, extracts selected tool-name literals, reports mapped and unmapped names plus confidence, and supports JSON. It is explicitly best-effort, does not translate arguments or configuration, includes the local source path in output, is not bound to an immutable source release or target catalog digest, and does not map authorization or recovery lifecycles. |
| MCP-native UX | Tools, resources, exact-ID completion, prompts, and progressive discovery are policy-aware parts of one contract. The embedded review application displays the same signed plan evidence the execution guard validates. | Cappyeo demonstrates progressive tool search and subscribed resources in its released server, and Hypark exposes useful Discord resources in its released server. Neither demonstrates the full combination of risk-separated dispatch, prompts, policy-aware completions, exact resource templates, and execution-bound review UX. |
| Real-time privacy | Real-time Gateway events are optional, separately scoped, bounded, privacy-projected, and excluded from durable content records. Privileged intents require separate reviewed justification. | Cappyeo has an optional Gateway and subscription resources in its released core. PaSympa connects through the Gateway and requests privileged intents by default in its released client. Neither demonstrates the same exact event policy, minimization, and intent-review boundary. REST-only projects are marked Different fit, not penalized. |
| Audit and observability | Privacy-safe observability combines content-free local activity, durable operation receipts, bounded metrics and traces, explicit export policy, redaction, and no ambient telemetry escalation. | Cappyeo has the strongest alternative with default audit output, redaction, optional OpenTelemetry, and optional OTLP audit-log export in its released audit and telemetry modules. Its ordinary results may remain raw, and it does not demonstrate the same content-free durable request, checkpoint, receipt, and reconciliation record model. |
| Distribution and supply chain | The release runbook verifies exact reproducible npm and MCPB archives, a hardened multi-architecture OCI image, deterministic embedded and external SBOMs, complete third-party notices, maximal build provenance, signed attestations, image signatures, credential-free contract evidence, checksums, immutable release assets, and cross-surface identity. The immutable GitHub Release is verified before its exact MCPB URL and SHA-256 are registered. | Hypark demonstrates excellent multi-format release engineering, cross-format bundle identity, SBOMs, maximal OCI provenance, trusted publishing, and signed bundle attestations in its released workflow. GuildControl MCP additionally validates exact ZIP structure, repeats the bundle build, embeds privacy, notices, SBOM, and catalog evidence, executes the unpacked server handshake, compares bundle bytes across supported Node runtimes, and makes the immutable public asset a prerequisite of Registry publication. |
| Documentation | The portal is generated from canonical docs, includes local search, task paths, a release-exact guided product tour and contract explorer, llms.txt, full machine-readable documentation, strict local-only assets and CSP, keyboard and responsive checks, WCAG scanning, source-digest binding, and this evidence ledger. | Cappyeo sets the strongest competing bar with an Astro/Starlight portal, tutorials, generated tool reference with access contracts, search, machine-readable entry points, rendered link and contrast checks, and a captioned live walkthrough. GuildControl MCP adds deterministic canonical-source adaptation, a credential-free offline tour bound to required negotiated prompts, tools, and access stages, complete protocol and lifecycle evidence, a privacy-enforced local-only runtime, full machine-readable source compilation, and the independently traceable field comparison. The guided tour is explicitly not evidence of live Discord execution. |
| Verification | The project verifies protocol contracts, policy non-escalation, Discord transport behavior, failure and recovery state machines, privacy invariants, exact package contents, reproducibility, OCI hardening, release evidence, documentation generation, links, browser behavior, accessibility, and model- and harness-neutral bytes. | Cappyeo's released CI and Hypark's released CI both demonstrate serious product and artifact verification. Neither demonstrates the same combined reviewed-operation, privacy, reproducibility, registry, contract-evidence, documentation, and release-frontier coverage. |
Components V2 template authoring head-to-head
Section titled “Components V2 template authoring head-to-head”Cappyeo 0.25.0 supplies the strongest released template idea in the Registry field. Its send-from-template implementation selects one of five bundled JSON layouts, interpolates a generic string map, validates the result, and uses its shared one-time payload approval before sending. Its announcement and release-notes layouts demonstrate the useful style-5 URL-button idea. GuildControl MCP keeps that convenience while defining the complete outcome as typed local authoring followed by the existing reviewed publication lifecycle and Discord's exact link-button contract.
| Reviewed template outcome | GuildControl MCP | Cappyeo 0.25.0 |
|---|---|---|
| Give every template a strict semantic input schema instead of a generic variable map | Lead | Not demonstrated |
| Reject unknown fields, malformed Unicode, multiline labels, unsafe counts, and invalid derived values before layout construction | Lead | Partial |
| Derive incident status text and accent plus poll totals, percentages, and pluralization deterministically | Lead | Not demonstrated |
| Compile locally without contacting Discord, granting authority, or sending | Lead | Not demonstrated |
| Return exact normalized components ready for a separate target-bound plan | Lead | Partial |
| Reuse one bounded static DSL with callback-free link rows but no custom ID, interactive style, remote media, attachment, raw component type, or arbitrary template source | Lead | Not demonstrated |
| Offer one typed announcement or release CTA while the custom DSL supports one to five bounded HTTPS style-5 link buttons with exact Discord label and URL limits | Lead | Partial |
| Normalize every destination and expose its exact URL plus unique sorted origin before authority is considered | Lead | Not demonstrated |
| Require every destination's exact canonical HTTPS origin in one strict policy and reject a mismatch before Discord access | Lead | Not demonstrated |
| State and enforce that the connector never fetches links, resolves DNS, follows redirects, inspects remote content, or guarantees a final destination | Lead | Not demonstrated |
| Project visible, notified, and suppressed user mentions through the ordinary exact-user policy | Lead | Not demonstrated |
| Publish a versioned data-free MCP resource catalog with exact fields, limits, lifecycle, and privacy boundaries | Lead | Not demonstrated |
| Participate in exact-tool search and complete progressive workflow activation | Lead | Partial |
| Bind publication to pinned identity, exact scope, intent, complete permissions, target state, reply policy, and one-shot plan evidence | Lead | Partial |
| Require signed host-visible execution, final freshness, durable coordination, pending content-free activity, and one non-retried mutation | Lead | Partial |
| Verify exact response and independent readback, then support restart-safe receipt-bound drift inspection | Lead | Not demonstrated |
| Verify deterministic compilation, every template family, strict rejection, MCP schemas, annotations, discovery, resources, docs, and package evidence | Lead | Partial |
Cappyeo's templates deliberately include useful link buttons plus higher-authority custom-ID buttons and an avatar thumbnail. GuildControl MCP adopts the link-button presentation idea and narrows it to callback-free style-5 HTTPS links whose complete normalized destinations are reviewed, whose exact first-hop origins are separately allowlisted before Discord access, whose rows and buttons share the ordinary recursive layout budget, and whose response and readback must match. Its typed template compiler still emits no custom ID or remote media. The separate managed request-row lifecycle adopts the useful private-action outcome without copying caller-defined identifiers or a generic callback surface. The connector also states the remaining link trust boundary plainly: it never fetches, resolves, follows, or verifies a destination, and an allowlisted first hop does not guarantee where a Discord client ultimately arrives.
Managed request Button head-to-head
Section titled “Managed request Button head-to-head”Cappyeo 0.25.0 provides the strongest released interactive-component building blocks in the Registry field: its strict component schema accepts Discord Button styles 1 through 4 with a caller-supplied custom ID, its validator enforces layout and ID uniqueness, and its sender applies bounded payload review before publication. GuildControl MCP keeps the useful visible-button outcome while defining a complete private-request lifecycle rather than an outbound component alone.
| Private request-button outcome | GuildControl MCP | Cappyeo 0.25.0 |
|---|---|---|
| Accept only a visible label and one of four fixed styles, never a caller-selected custom ID | Lead | Not demonstrated |
| Bind every generated ID to exact application, bot, guild, channel, complete layout, one-shot operation, button index, label, and style | Lead | Not demonstrated |
| Stay restart-safe without a callback registry or route database | Lead | Not demonstrated |
| Require exact native Interaction guild, channel, and user scope plus a ready paired broker and contract-matching managed command before publication | Lead | Not demonstrated |
| Freshly verify Gateway delivery, pinned identities, command readiness, and exact authorized user IDs in the publication plan, then invalidate execution when any ingress evidence changes | Lead | Not demonstrated |
| Publish only through signed review, durable one-shot coordination, one non-retried mutation, exact response validation, and independent readback | Lead | Partial |
| Admit a click only after authenticating the attached source and freshly fetching the exact source message plus command inventory | Lead | Not demonstrated |
| Ignore unrelated custom IDs and privately reject malformed or stale managed IDs | Lead | Not demonstrated |
| Require an exact user allowlist without granting write or administration authority | Lead | Not demonstrated |
| Keep the Interaction token broker-private and expose only a bounded opaque one-shot request reference | Lead | Not demonstrated |
| Share global and per-user capacity, expiry, deduplication, response, and continuation limits with the native request broker | Lead | Not demonstrated |
| Validate source-specific component response metadata and the exact source-message reference | Lead | Not demonstrated |
| Keep request text, label, custom ID, and route out of durable records, logs, diagnostics, and telemetry | Lead | Not demonstrated |
| Make token rotation explicitly invalidate old routes and fail closed | Lead | Not demonstrated |
| Reject request rows in private messages, where the exact-guild broker boundary cannot be proved | Lead | Not demonstrated |
Cappyeo's released Gateway client is a useful subscription implementation, but its registered handlers do not include Interaction events. Its separate Interaction response tools begin after another system has received an event and require the caller to provide the reusable token. This is valuable lower-level coverage, recorded as Partial, but it is not evidence of an end-to-end button ingress lifecycle. GuildControl MCP intentionally does not turn the feature into arbitrary callback dispatch, selects, modals, automatic tool calls, or direct moderation; those remain separate authority designs rather than missing switches.
Host configuration drift head-to-head
Section titled “Host configuration drift head-to-head”Cappyeo provides the strongest released host-maintenance idea in the audited field. Its update implementation recognizes one generated launcher, reports a newer npm release without changing the file by default, and requires explicit application before an atomic rewrite. GuildControl MCP keeps the valuable detect-before-change and warning-exit ideas while defining the outcome as exact local configuration verification rather than online release discovery or automated host mutation.
| Host-configuration outcome | GuildControl MCP | Cappyeo 0.25.0 |
|---|---|---|
| Compare every supported generated adapter from one activation contract | Lead | Partial |
| Bind expected bytes to the installed release and selected strict policy | Lead | Partial |
| Require one explicit file and adapter without home-directory or host discovery | Lead | Partial |
| Inspect without network, registry, Discord, process launch, policy change, or activity state | Lead | Partial |
| Keep inspection permanently read-only with no apply or rewrite mode | Lead | Covered |
| Require bounded duplicate-free JSON, a canonical regular single-link stable read, and private owner and mode checks where portable | Lead | Partial |
| Compare only the owned server and sensitive-input projection in shared host files | Lead | Partial |
| Compare a dedicated extension manifest as one complete exact document | Lead | Not demonstrated |
| Ignore unrelated shared-host state without returning, counting, hashing, or assessing it | Lead | Partial |
| Return only fixed difference categories without observed values, raw host content, or the selected path | Lead | Partial |
| Bind deterministic inspection evidence to both adapter and activation digests | Lead | Not demonstrated |
| Distinguish exact match, drift warning, and command failure through stable exit statuses | Lead | Covered |
Regenerate the exact recovery fragment, then hand real startup and Discord proof to smoke | Lead | Partial |
| Verify exact and stale files through unit, CLI, exported-library, and installed-package release tests | Lead | Partial |
The command is intentionally not an updater. A match proves only one stable static projection at inspection time; it cannot prove that the host loaded that file, retained it, forwarded a secret, honored approval or elicitation, negotiated MCP, or reached Discord. Drift therefore returns status 1, preserves the file byte for byte, and directs the operator to merge only the regenerated owned projection, reload the host, rerun inspection, and finish with smoke.
Migration planning head-to-head
Section titled “Migration planning head-to-head”Cappyeo provides the strongest released switching idea in the audited field. Its adapter contract separates detection from migration and reports mapped, unmapped, manual-review, warning, and confidence evidence. The released adapter registry includes several GuildControl MCP source families. GuildControl MCP retains the valuable explicit accounting and machine-output idea while defining the complete operator outcome as a safe switch between published contracts rather than a best-effort source-code rename pass.
| Migration-planning outcome | GuildControl MCP | Cappyeo 0.25.0 |
|---|---|---|
Select one immutable product@version source contract | Lead | Not demonstrated |
| Account for every audited public source tool exactly once | Lead | Partial |
| Preserve tagged versus version-matching source-audit fidelity | Lead | Not demonstrated |
| Cover every release in the scored local comparison | Lead | Partial |
| Read no arbitrary source checkout or source configuration | Lead | Not demonstrated |
| Expose no caller-local source path in the plan | Lead | Not demonstrated |
| Map operator outcomes and trust-model changes, not names alone | Lead | Partial |
| Validate every target tool against the negotiated production catalog | Lead | Not demonstrated |
| Route least-privilege setup through exact presets, additive recipes, and the policy workbench | Lead | Not demonstrated |
| Distinguish supported, review-required, and intentionally excluded behavior | Lead | Partial |
| State explicitly that arguments, configuration, credentials, prompts, and host settings are not rewritten | Lead | Covered |
| Deterministic source inventory, manifest, catalog, target contract, plan, and HTML evidence | Lead | Partial |
| Complete human and JSON reports plus private standalone searchable HTML | Lead | Partial |
| No credential, environment value, network, Discord call, process launch, policy mutation, or activity record | Lead | Partial |
| Reject unversioned aliases, source paths, and nearest-version substitution | Lead | Not demonstrated |
| Tests bind the migration catalog to every scored release and every canonical target route | Lead | Not demonstrated |
Cappyeo's clone scanner is useful when an operator has source code containing recognizable literal tool names and wants a quick rename inventory. It recursively reads selected TypeScript trees, applies a static map, and honestly leaves argument conversion to manual work. GuildControl MCP does not claim to import that source, and it deliberately refuses a checkout path. Its migration guide instead gives every audited source operation a disposition, shows the safer target lifecycle, emits exact staged commands with invalid placeholders, and leaves both the old deployment and new strict policy untouched until the operator takes each reviewed step.
Native Interaction continuation head-to-head
Section titled “Native Interaction continuation head-to-head”Cappyeo supplies the strongest competing Interaction endpoint family: create, get, edit, and delete operations for the original response and follow-ups. Its follow-up creator directly inspired this audit checkpoint. GuildControl MCP adopts the useful long-running response outcome while keeping the reusable token inside an exact-scope ingress broker. The focused rubric scores the safe end-to-end operator lifecycle defined by Discord's Interaction response contract, not the number of raw webhook endpoints exposed.
| Native Interaction response outcome | GuildControl MCP | Cappyeo 0.25.0 |
|---|---|---|
| Answer one private command and continue a bounded long-running exchange | Lead | Covered |
| Reusable Discord Interaction credential never crosses MCP | Lead | Not demonstrated |
| Exact application, bot, guild installation, command, channel, and user binding before exposure | Lead | Not demonstrated |
| Default token disposal with explicit opt-in retention only after verified completion | Lead | Not demonstrated |
| Shared global and per-user capacity across pending, continuation, and in-flight work | Lead | Not demonstrated |
| Rotating one-shot capability references with fixed lifetime and follow-up ceiling | Lead | Not demonstrated |
| Ephemeral bounded plain text with mentions and rich fields disabled | Lead | Partial |
| Durable content-free pending activity before every response write | Lead | Not demonstrated |
| One explicitly non-retried follow-up write | Lead | Partial |
| Strict direct response plus independent exact GET readback | Lead | Partial |
| Refusal distinction, ambiguity quarantine, and consumed-reference recovery boundary | Lead | Not demonstrated |
| Token-free status, list tool, subscribed resource, progressive discovery, and plan-only prompt | Lead | Partial |
| Persistent evidence excludes request text, response text, token, profiles, and raw payloads | Lead | Not demonstrated |
Cappyeo's broader endpoint family is useful when a caller already owns an Interaction token and wants raw response CRUD. Its schemas accept that token as an MCP argument plus caller-selected embeds, components, attachments, allowed mentions, TTS, flags, payload JSON, and polls. That flexibility is deliberately outside GuildControl MCP's broker boundary. More importantly, Cappyeo's guild-allowlist middleware documents that opaque-token Interaction tools cannot prove their target guild and therefore fail closed under an active guild allowlist. Its create call returns IDs, and a separate get tool exists, but the release does not bind creation to mandatory independent readback or consume a caller's reusable token after ambiguity.
GuildControl MCP's token-private workflow receives the event itself, validates exact ingress scope, defers ephemerally, and exposes only a one-shot iref_... reference. The initial response closes by default. Explicit keepOpen can return one icref_... continuation only after durable completion; every follow-up consumes that reference before one non-retried write, validates the exact response and readback, and returns a different reference only after complete success. The sequence remains process-local, expires before Discord's token window, stops after three follow-ups, and ends without rotation after refusal, uncertainty, drift, failed completion recording, or shutdown.
Application Activity-instance head-to-head
Section titled “Application Activity-instance head-to-head”Cappyeo 0.25.0 supplied the strongest released Activity-instance idea in this audit. Its application_get_activity_instance tool calls Discord's exact raw endpoint and exposes the returned application, instance, optional launch, location, and user fields. GuildControl MCP adopts the useful session-verification outcome while treating Discord's response as untrusted identity, location, and participant evidence rather than returning it wholesale. The rubric follows Discord's Application Activity Instance contract and multiplayer Activity guidance.
| Activity-instance verification outcome | GuildControl MCP | Cappyeo 0.25.0 |
|---|---|---|
| Fetch one caller-known running Activity instance | Lead | Covered |
| Target only the configured and verified current application and bot | Lead | Partial |
| Require one exact expected guild and channel inside ordinary read policy before the instance read | Lead | Not demonstrated |
| Validate returned application and instance identity instead of reflecting it | Lead | Not demonstrated |
| Accept only the exact expected public guild-channel location | Lead | Not demonstrated |
| Reject private-channel and mismatched location evidence without returning it | Lead | Not demonstrated |
| Bound the opaque ID, response bytes, object fields, location fields, and participant evidence | Lead | Partial |
| Represent exact not-found as structured inactive or unavailable state without masking other failures | Lead | Not demonstrated |
| Return participant count without participant enumeration | Lead | Not demonstrated |
| Answer optional membership for one caller-supplied exact user without exposing anyone else | Lead | Partial |
| Count unknown fields while omitting their values and every raw payload | Lead | Not demonstrated |
| Persist and export no instance, location, launch, or participant evidence | Lead | Not demonstrated |
| Read-only annotation, progressive discovery, safety guide, task reference, and explicit snapshot limits | Lead | Partial |
Cappyeo's released schema is useful and typed, but it accepts both application_id and instance_id from the caller, interpolates both into the raw path, and returns the complete optional location record and users array. Its handler does not demonstrate an expected guild-channel boundary, a pinned same-application check, a public-location restriction, strict response identity validation, participant minimization, structured inactive state, or a workflow-specific persistence contract.
GuildControl MCP's inspect_application_activity_instance accepts only the Activity client's opaque instance ID, exact expected guild and channel, and an optional exact user. It derives the application from verified configuration, encodes the route segment, rejects malformed or oversized evidence before projection, and exposes only the location the caller already supplied, launch ID, participant count, optional exact-user boolean, and count-only future evidence. The result is explicitly one transient snapshot. It does not launch or join an Activity, connect to voice, or claim durable membership or authorization.
Soundboard playback head-to-head
Section titled “Soundboard playback head-to-head”Cappyeo 0.25.0 supplies the strongest released playback primitive in the Registry field: its soundboard_send_sound tool accepts one channel, sound, and optional source guild, publishes correct non-read-only and non-destructive annotations, and declares core and conditional permissions through its access registry. TheETR's moving source head adds guild policy, channel-to-guild resolution, and dry-run to the same useful outcome in its combined discord_soundboard tool. GuildControl MCP adopts the endpoint while treating audible playback as an externally observable write whose safe completion depends on fresh exact readiness, duplicate containment, and honest ambiguity handling. The rubric follows Discord's soundboard playback contract and exact Gateway effect event.
| Soundboard playback outcome | GuildControl MCP | Cappyeo 0.25.0 | TheETR source head |
|---|---|---|---|
| Play one exact default or custom sound in one exact voice channel | Lead | Covered | Covered |
| Independent exact target-channel and custom-source-guild policy | Lead | Partial | Partial |
| Pinned application and bot identity before readiness or write | Lead | Partial | Partial |
| Fresh ordinary voice-channel type, exact guild, complete role, and overwrite evidence | Lead | Not demonstrated | Partial |
| Exact current bot connection with blocking voice-state fields rejected | Lead | Not demonstrated | Not demonstrated |
Complete VIEW_CHANNEL, CONNECT, SPEAK, USE_SOUNDBOARD, and conditional USE_EXTERNAL_SOUNDS proof | Lead | Partial | Partial |
| Exact default inventory or custom-source lookup with availability proof | Lead | Not demonstrated | Not demonstrated |
| Separate read-only readiness tool that persists nothing | Lead | Not demonstrated | Not demonstrated |
| Visibly guarded non-destructive write contract for compatible MCP hosts | Lead | Covered | Partial |
| Request-bound one-shot key, exact durable replay, and mismatch conflict | Lead | Not demonstrated | Not demonstrated |
| Durable cross-process channel exclusion and shared anti-spam limits | Lead | Not demonstrated | Not demonstrated |
| Pending content-free receipt and activity before audible effect | Lead | Not demonstrated | Not demonstrated |
| One explicitly non-retried request with strict empty-success validation | Lead | Partial | Partial |
| Exact guild, channel, bot, and sound Gateway corroboration without event retention | Lead | Not demonstrated | Not demonstrated |
| Determinate refusal distinction, ambiguous-result quarantine, and no new-key retry | Lead | Not demonstrated | Not demonstrated |
| Persistent evidence excludes names, voice profiles and state, permissions, and raw payloads | Lead | Partial | Not demonstrated |
| Setup diagnostics, progressive discovery, safety contract, and honest voice-session limitation | Lead | Partial | Partial |
Cappyeo's released action is compact and well typed. Its handler sends the request immediately after the shared middleware path, while its own description tells the caller that the bot must already be connected. The permission registry names VIEW_CHANNEL, SPEAK, USE_SOUNDBOARD, and conditional USE_EXTERNAL_SOUNDS, but the release does not prove CONNECT, ordinary voice type, the current bot connection and blocking state, or exact sound availability inside this action. Its optional runtime access mode can enforce declared requirements, but defaults to advisory and does not add the playback-specific readiness, durable replay, pending record, Gateway evidence, or recovery lifecycle scored here.
TheETR's source-head action verifies that the caller's channel belongs to the selected allowlisted guild, applies the same guild policy to a supplied source, and offers dry-run. Its documented setup names Speak, Use Soundboard, and Use External Sounds. The action does not demonstrate a separate channel or custom-source allowlist, pinned application identity, complete permissions and current voice-state proof, exact sound lookup, write annotations, durable one-shot replay, pending content-free activity, event corroboration, or ambiguous-outcome quarantine.
GuildControl MCP's guarded playback path deliberately does not join voice. An independently managed session for the same bot must already occupy the exact target. The read-only check and the write each rebuild exact channel, identity, role, overwrite, permission, voice-state, and sound evidence. The write then claims the channel, spends one request-bound key, applies shared rate controls, journals pending state, begins an exact privacy-discarding event waiter, and sends once. A strict REST 204 completes even without the event; a matching event adds corroboration; an event never rescues an ambiguous REST result. This yields useful audible behavior without pretending the endpoint is idempotent, observable by readback, or safe to retry under a new key.
Parent-category permission-sync head-to-head
Section titled “Parent-category permission-sync head-to-head”Oratorian exposes a dedicated discord_sync_channel_permissions call backed by discord.js lockPermissions(). Cappyeo exposes the underlying complete permission_overwrites channel field rather than a parent-specific sync workflow. Both are useful ideas. The focused rubric scores the complete operator outcome defined by Discord's permission-syncing semantics: replacing a child's overwrite set to match its parent also opts that child into later parent propagation until the child changes independently.
| Parent-category synchronization outcome | GuildControl MCP | Oratorian 1.1.4 | Cappyeo 0.25.0 |
|---|---|---|---|
| Dedicated capability, toolset, and exact direct-child allowlist | Lead | Partial | Partial |
| Live exact parent derivation and supported child-type boundary | Lead | Partial | Not demonstrated |
| Complete current, parent, and changed-target structural review | Lead | Not demonstrated | Not demonstrated |
| Protected-member boundary without member-profile collection | Lead | Not demonstrated | Not demonstrated |
| Complete current-child, parent, and prospective-child connector authority proof | Lead | Not demonstrated | Partial |
| Explicit complete-replacement, future-propagation, and stopped-concurrency acknowledgments | Lead | Not demonstrated | Not demonstrated |
| Process-keyed plan, signed request state, and repeated freshness checks | Lead | Not demonstrated | Not demonstrated |
| Destructive annotation, host write approval, and interactive plan-bound confirmation | Lead | Not demonstrated | Not demonstrated |
| Durable exact child-and-parent coordination, one-shot reservation, and pending content-free activity | Lead | Not demonstrated | Not demonstrated |
| One narrow non-retried complete-overwrite mutation | Lead | Not demonstrated | Not demonstrated |
| Record-free no-op plus exact response and independent fresh synchronized-state readback | Lead | Not demonstrated | Not demonstrated |
| Settled-failure distinction, uncertainty quarantine, and explicit recovery boundary | Lead | Not demonstrated | Not demonstrated |
| Plan-only prompt, progressive discovery, doctor guidance, and durable privacy documentation | Lead | Partial | Partial |
Oratorian's strict input contains only the child channel ID. Its handler looks up one cached guild channel, calls lockPermissions(), and returns a textual confirmation. The tool is marked non-destructive and idempotent, and the released implementation does not demonstrate an independent exact sync scope, parent or overwrite review, authority or protected-member proof, consequence acknowledgments, target-bound confirmation, one-shot persistence, non-retried transport, independent readback, or ambiguous-outcome recovery.
Cappyeo's generic modifier accepts a complete caller-supplied overwrite array containing raw target IDs, target types, and optional decimal allow and deny strings, then passes that array through one channel PATCH. Its broader project supplies useful global allowlisting and access middleware, but this released tool is marked non-destructive and provides no parent derivation or synchronization semantics. It does not demonstrate a parent-bound plan, complete delta and prospective-authority proof, consequence acknowledgments, signed confirmation for this change, child-and-parent coordination, exact synchronized-state readback, or sync-specific recovery.
GuildControl MCP's reviewed workflow accepts no source ID and no bitfield. It derives the live parent from one allowlisted direct child, compares both complete sets, checks every referenced role and protected changed member, proves connector continuity before and after, and explains the structural member-analysis limit. Execution then binds signed approval to that fresh evidence, coordinates both exact channels, records a one-shot pending lifecycle, sends one non-retried permission_overwrites replacement through Discord's Modify Channel endpoint, and independently proves exact synchronization. A lost or contradictory result remains quarantined rather than becoming a retry or optimistic success.
Bot-installation drift head-to-head
Section titled “Bot-installation drift head-to-head”Cappyeo supplies the strongest released installation-discovery baseline. Its setup command verifies a bot, paginates installed guilds in pages of 200 with counts disabled, rejects duplicate guild IDs, and helps validate or select an allowlist. Its separate runtime tool exposes one caller-controlled guild page. The focused rubric defines the durable operator outcome as proving whether one pinned bot is installed in exactly the guilds named by its active local policy, without collecting guild presentation or silently converting visibility into authority.
rayenking's source-head guild discovery tool returns the connected bot's guild IDs, names, and icons. HardHeadHackerHead's source-head guild listing returns cached IDs, names, member counts, the configured guild ID, and an isConfigured marker. These are useful inventory views, but neither publishes the same complete, names-free expected-versus-installed audit or operator-diagnostic lifecycle.
| Bot-installation drift outcome | GuildControl MCP | Cappyeo 0.25.0 | rayenking source head | HardHead source head |
|---|---|---|---|---|
| One fixed read-only operation compares the active exact configured set with the installed set | Lead | Partial | Not demonstrated | Partial |
| Verified pinned current application and bot identities | Lead | Partial | Not demonstrated | Not demonstrated |
| Server-side pagination begins at a fixed zero cursor and reaches a short or empty terminator | Lead | Partial | Partial | Partial |
| Every request fixes the maximum page size and disables approximate member and presence counts | Lead | Partial | Not demonstrated | Not demonstrated |
| Guild objects become unique canonical IDs immediately at the REST boundary | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| Names, icons, ownership, permissions, features, counts, and raw payloads are omitted | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| Duplicate, malformed, non-advancing, oversized, and cross-page-invalid evidence fails the whole result | Lead | Partial | Not demonstrated | Not demonstrated |
| Per-response byte bound, hard installed-guild bound, and empty terminator at the exact bound | Lead | Partial | Not demonstrated | Not demonstrated |
| Exact configured, installed, installed-in-scope, missing, and unexpected ID sets | Lead | Partial | Not demonstrated | Partial |
| Unexpected installation visibility grants no scope and triggers no policy mutation or departure | Lead | Partial | Not demonstrated | Not demonstrated |
| Same implementation backs setup, online doctor, smoke, connector status, and direct audit | Lead | Partial | Not demonstrated | Not demonstrated |
| Standard MCP tool, private fixed resource, dedicated one-call prompt, and progressive discovery | Lead | Partial | Partial | Partial |
| Fixed privacy evidence, no persistence, and explicit non-atomic multi-page limitation | Lead | Partial | Not demonstrated | Not demonstrated |
Cappyeo's setup flow is a strong pre-configuration experience, but it returns bot and guild presentation, has no pinned application identity or hard total inventory bound, and does not turn the saved allowlist into a recurring complete drift classification. Its runtime tool is honestly paginated, but the caller must drive and compare pages and may request approximate counts. The two surfaces do not demonstrate one shared result enforced by setup, status, diagnostics, smoke, resource, and prompt.
GuildControl MCP's complete installation audit performs only the endpoint reads required for ID-set comparison. Missing configured installations fail setup and online verification; unexpected IDs warn without entering scope. The audit refuses partial success when completion cannot be proved and persists nothing. Its complete status describes a bounded pagination run, not an atomic Discord snapshot, channel visibility, permission readiness, future membership, or permission to remediate automatically.
Guild-departure head-to-head
Section titled “Guild-departure head-to-head”Two audited releases expose bot departure as a callable operation: Cappyeo's users_leave_guild and Oratorian's discord_leave_guild. GuildControl MCP implements the same useful outcome as a separate reviewed lifecycle rather than a direct mutation. The focused rubric below was defined around the irreversible operator outcome, not around internal implementation similarity.
| Guild-departure outcome | GuildControl MCP | Cappyeo 0.25.0 | Oratorian 1.1.4 |
|---|---|---|---|
| Dedicated capability and exact departure allowlist | Lead | Partial | Partial |
| Pinned application, bot membership, and non-owner evidence | Lead | Partial | Partial |
| Complete current-guild inventory with privacy projection | Lead | Not demonstrated | Not demonstrated |
| Separate access-loss, re-entry, and stopped-work acknowledgments | Lead | Partial | Partial |
| Keyed plan, reviewed evidence, and repeated freshness checks | Lead | Not demonstrated | Not demonstrated |
| Destructive annotation, host approval, and signed interactive confirmation | Lead | Partial | Partial |
| Durable collection coordination with an explicit quiescence boundary | Lead | Not demonstrated | Not demonstrated |
| Durable one-shot reservation and pending content-free activity | Lead | Not demonstrated | Not demonstrated |
| One explicitly non-retried mutation | Lead | Not demonstrated | Not demonstrated |
| Complete fresh target-absence readback | Lead | Not demonstrated | Not demonstrated |
| Settled-failure distinction, uncertainty quarantine, and spent-key recovery boundary | Lead | Not demonstrated | Not demonstrated |
| Setup diagnostics, plan-only prompt, privacy contract, and operator recovery guidance | Lead | Partial | Partial |
Cappyeo supplies a useful global guild allowlist, runtime access requirements, a default dry-run posture, destructive annotation, and a caller-provided __confirm gate. Its released departure handler then sends the delete and returns {left, guild_id}; it does not demonstrate a departure-specific allowlist, complete inventory and ownership plan, signed approval bound to fresh state, durable one-shot reservation, pending content-free record, explicit no-retry contract, absence readback, or uncertainty quarantine. See its access requirement mapping, confirmation precondition, and released handler.
Oratorian requires an exact guild ID, checks the client cache, marks the tool destructive, warns that reinvitation is required, and requires confirm: true. Its strict input schema and released handler do not demonstrate an independent scope gate, pinned application and bot proof, a complete privacy-bounded membership snapshot, reviewed planning, signed confirmation, durable coordination or reservation, non-retried transport, absence readback, or uncertain-outcome recovery.
GuildControl MCP's reviewed exact guild-departure lifecycle verifies the pinned identities, exact bot member, non-ownership, and every bounded page of current guild membership while projecting every other guild identity out. It then requires three literal consequence acknowledgments, a process-keyed plan, a signed confirmation round, final fresh checks, durable claims across every modeled guild collection, a one-shot reservation, pending content-free activity, one non-retried request, and complete absence readback. It also documents the honest coordination limit: collection claims do not identify every resource-only or external operation, so operator-controlled quiescence remains mandatory. Discord's route itself returns an empty success and fires guild-removal events; it does not provide the workflow-level evidence above. See the official Leave Guild endpoint.
Adjacent bot-profile head-to-head
Section titled “Adjacent bot-profile head-to-head”The Registry result captured on 2026-08-29 does not include TheETR's untagged Thee GuildControl MCP source, so it is not mixed into the release-exact scored matrix above. Its source head was nevertheless audited on that date because its current-bot profile tool supplied the strongest adjacent feature idea. This narrower comparison applies the same evidence rules to that workflow rather than ignoring a useful unregistered competitor.
| Bot-profile operator outcome | GuildControl MCP | TheETR source head |
|---|---|---|
| Explicit mutation surface | Lead: exact username, avatar, and banner variants with unknown fields rejected | Partial: accepts a generic caller-supplied JSON object |
| Image input custody | Lead: bounded process-owned regular single-link files inside configured canonical roots | Partial: accepts image data inside the caller-supplied JSON body |
| Target identity | Lead: configured application and bot IDs are freshly verified against both application and current-user evidence | Partial: targets the current token through /users/@me without a separately pinned application-and-bot contract |
| Review and freshness | Lead: keyed remote-and-file plan, signed MCP request state, interactive confirmation, and final complete plan match | Partial: short-lived one-time confirmation binds a digest of the supplied body |
| Durable exclusion and audit | Lead: application-wide claim, one-shot reservation, and pending content-free activity precede the write | Not demonstrated for this tool |
| Mutation and verification | Lead: one sparse non-retried PATCH, strict response projection, and independent exact editable-state readback | Partial: one raw-body PATCH returns the direct response |
| Ambiguous failure and recovery | Lead: spent key, retained application claim, same-application quarantine, and explicit operator resolution | Not demonstrated for this tool |
| Persistent privacy | Lead: username, paths, image metadata, hashes, bytes, rationale, and raw payloads are absent from durable records | Partial: preview redacts image fields, but no content-free durable lifecycle record is demonstrated |
The TheETR evidence comes from its current-bot profile registration and handler. The local workflow and its limits are documented in Reviewed authenticated bot-profile lifecycle.
Broader unregistered field scan
Section titled “Broader unregistered field scan”The Registry matrix remains release-exact, but idea discovery also needs public projects that have not published an official Registry record. A source-head scan captured on 2026-08-29 widened the field without mixing moving branches into the scored release table. These projects have materially different deployment, identity, and persistence models, so the disposition records what was learned rather than pretending every feature belongs in a local bot-token connector.
| Public source head | Distinctive idea or product shape | GuildControl MCP disposition |
|---|---|---|
| HardHeadHackerHead | Broad discord.js administration and a feature-aware vanity URL read | Adopt the useful vanity audit outcome, then add exact policy, pinned identity, permission proof, default code redaction, strict evidence, and MCP-native guidance |
| arrrnmp | Broad typed service surface with guild allowlisting, dry-run support, and a direct vanity summary | Adopt the typed vanity summary while strengthening disclosure, feature and permission evidence, response consistency, and persistence boundaries |
| glittercowboy | Very broad direct REST coverage, including vanity read and a direct vanity PATCH | Adopt only the documented read; reject the mutation because Discord's public guild resource contract does not document that route |
| Rastrian | Hosted multi-tenant OAuth workspaces, policy layers, audit, automation, and a Discord-resident agent | Different fit: useful for a shared control plane, but not a reason to move a local connector's credentials, Discord content, or authority into a hosted service |
| sandraschi | Local dashboard, RAG ingestion, sampling-driven workflows, and bundled operational guides | Preserve the no-content-persistence boundary; retain the dashboard and workflow ideas as candidates only where they can remain private, optional, and model-neutral |
| Soyouse | Multi-bot session isolation, an invalid-request monitor, raw REST pass-through, a web client, and a persistent history relay | Keep the multi-bot and shared-rate-safety lessons; reject raw endpoint authority and mandatory history persistence in favor of explicit bounded contracts |
| SaseQ | JDA implementation with stdio and HTTP modes, container installation, health checks, and a broad conventional tool surface | Retain transport and health-check ideas while preserving deterministic native package and MCPB installation that does not require Docker |
| goul4rt | Standalone or embedded discord.js operation, optional Gateway behavior, and broad monitoring and administration coverage | Do not add embeddability unless it preserves one policy source, fixed-origin REST, privacy projections, and reviewed writes |
| NacreousDawn596 | A Discord-resident autonomous agent with provider fallback, guild-scoped memory, natural-language schedules and automations, server audits, and name-based ensure_* operations | Retain declarative idempotence, audit guidance, and multi-guild isolation through exact-ID plans, strict caller-retained blueprints, verified readback, host-visible prompts, and policy; keep embedded models, stored natural-language memory, and autonomous schedules outside the connector |
| TheETR | A broad grouped operation surface with centralized safety tiers, dry-run planning, confirmation, readiness checks, blueprints with numeric channel positions and symbolic parents, and current-bot profile control | Retain the useful profile, readiness, and declarative ordering outcomes while strengthening them with pinned application identity, exact or receipt-bound targets and anchors, purpose-built schemas, target-specific policy, standard progressive MCP discovery, signed fresh review, durable coordination, overwrite preservation, and exact dual-source readback |
| TinyGecko | A compact declarative provisioner with create-only and reconcile modes, unmanaged omitted fields, role ordering, channel creation positions with a separate manual reorder tool, known-role permission-overwrite convergence, orphan reporting, a whole-plan dry run, and bundled server-design templates | Retain its compact convergence outcomes while strengthening them with exact or receipt-bound role and channel identities, bottom-up one-adjacency planning, exact-channel one-target overwrites, whole-manifest review, deterministic ordered starters, fresh per-frontier evidence, and no name adoption, broad partial apply, or automatic write retries |
| Seretos | A host-specific plugin wrapper that combines an exact package pin, a sensitive installer prompt, automatic MCP launch, and a compact operational skill | Preserve the low-friction secret prompt and launch outcome through the model-neutral MCPB and generated adapters; do not make connector safety depend on one host's skill text, keychain behavior, or destructive-call confirmation |
| spranab | One hierarchical catch-all MCP tool that reveals categories and actions in stages before dispatching a broad direct-operation surface | Retain staged discovery through standard exact tools, native input schemas, annotations, tools/list_changed, reviewed workflow companions, and toolset policy rather than hiding authority behind one dynamic parameter map |
| jgrancell | A resumable full-history Markdown miner paired with a read-only Streamable HTTP live-context server, run reports, health checks, and optional bearer authentication | Different fit: retain explicit completeness, capability-gap, and health evidence, but do not introduce a content archive or remote bearer surface into a local non-persistent connector |
| bookedsolidtech | A particularly strong Discord-as-coordination-bus playbook with exact task-message keys, direct-reply collection, reaction conventions, task-boundary polling, threads, native polls, project routing, personas, and a directed note board | Provide both exact-task and directed-note outcomes through strict caller-retained opaque addresses, body-free observed-address reads, filtered bounded note reads, guarded idempotent sends, aggregate-safe signals, static model-neutral guidance, and one-shot prompts; preserve reviewed message, thread, and poll lifecycles while rejecting display identity as authority, implicit name routing for protected actions, connector-owned task content, and background polling |
| cael-agent | Compact one-call new-message checks and human-focused previews across one configured guild, per-channel high-water state, exact-message follow-up, bot filtering, and optional timestamp overrides | Adopt the high-value multi-channel catch-up outcome while requiring explicit exact scope, caller-retained independent cursors, complete access preflight, loss-resistant page advancement, no silent partial channels, smaller profile-free previews, and one-shot model-neutral guidance without a local inbox or project-specific safety sidecar |
| leeguooooo | A compact native Rust stdio server with direct REST calls, a small binary, and notably low idle memory alongside a conventional broad operation set | Selection-before-registration plus a verified memory-optimized Node launch substantially reduce excluded-catalog and runtime overhead, but the native implementation keeps a substantial idle-memory lead; retain that honest limitation without trading away strict secret custody, exact policy, protocol guidance, reviewed writes, or cross-surface verification |
| diocata | A focused local TypeScript server with grouped tools, default-off writes, exact MCP annotations, a clear macOS Discord setup path, live smoke coverage, and compact architecture diagrams | Retain its strong setup and smoke-test ergonomics while keeping the broader strict policy, generated multi-host activation, complete readiness contracts, privacy projections, and reviewed write lifecycles |
| vibhanshu-mishra | Local SQLite history, engagement and response analytics, evidence packets, operational backup/export/pruning, an MCPB, and a central content-output policy | Different fit: retain privacy-safe aggregate community analysis and explicit output boundaries without storing Discord content, profiles, membership history, reactions, threads, or voice sessions |
| fmarcac | A Discord desktop-client CDP bridge with direct and group-message access, a central operation-risk catalog, hidden destructive groups, and cached user-session headers | Different fit: preserve explicit risk classification and tool removal, but reject user-account automation, client modification, reusable user-session custody, and direct-message reach beyond one-to-one bot conversations |
| MADPANDA3D | Broad policy-wrapped administration with a raw typing-indicator action, write toggle, channel allowlist, caller confirmation, audit logging, and a non-retry test | Adopt the useful processing-feedback outcome while binding it to fresh user intent, pinned identity, complete permission evidence, a dedicated MCP contract, shared anti-spam controls, and content-free lifecycle evidence |
| rayenking | A broad bot-token surface with full message payloads and caller-URL attachment downloads to a shared temporary directory | Retain the explicit attachment-consumption outcome while rejecting caller-supplied delivery capabilities, unbounded buffering, caller-selected paths, and local-file persistence |
| LawyerCord | A Discord-client bridge that returns downloaded attachments as native MCP image, audio, or resource-link blocks | Adopt the useful native-result idea while adding bot identity and exact policy, signed-delivery proof, protocol-budgeted streaming, signature verification, generic embedded fallback, and disk-free transient custody |
| blackgirlbytes | Live vague-memory recall with multi-phrase relevance fusion and separate context, plus optional SQLite-backed community research | Adopt the excellent live phrase-fusion outcome while adding exact local scope, pinned identity, content-free indexing behavior, automatic fresh target-bound context, phrase-redacted results, strict evidence, no content persistence, and MCP-native prompt and completion ergonomics |
| TheStreamCode | Structured guild snapshots, diffs, a backup-or-explicit-opt-out deletion guard, and conservative automatic restore with documented losses | Adopt the explicit recovery-choice idea as a fresh signed exact-target attestation; retain caller custody and omission review, and reject broad connector-side snapshot persistence or automatic rollback authority |
| A7medr2694 | A Discord user-account client with local SQLite archive, browser fingerprinting, and command-line access to ordinary account behavior | Different fit: reject self-bot and user-session automation plus content archiving because they conflict with Discord's bot model, token custody, and the connector's non-persistence boundary |
| SACRVM | A broad administrative HTTP service that accepts a bot token per request and recommends high guild authority for direct changes | Retain no reusable per-request credential channel and no broad role recommendation; preserve process-owned bot-token custody, exact least-privilege setup, target-specific policy, and reviewed write lifecycles |
Declarative guild-convergence head-to-head
Section titled “Declarative guild-convergence head-to-head”TinyGecko's source-head apply_blueprint workflow supplies the strongest compact declarative provisioning design found in the wider scan. Its planner combines role and channel creation, existing-field updates, role ordering, and known-role channel-overwrite convergence in one ordered diff, while its starter catalog and design guidance make common layouts discoverable. TheETR's example blueprint contributes useful topics, forum-first support, settings, and welcome presentation, while its blueprint engine returns a complete action list from one live planning pass and can apply that list in one call, but can fall back from tracked IDs to names and combines structural and presentation effects. Both source heads were rechecked on 2026-08-29. GuildControl MCP adopts the high-value convergence, whole-manifest review, and starter-authoring outcomes while keeping exact identity, target-specific authority, local deterministic compilation, one-frontier review, durable receipts, and ambiguity quarantine inside each domain.
| Declarative outcome | GuildControl MCP | TinyGecko source head | TheETR source head |
|---|---|---|---|
| Additive structure plus existing role, hierarchy, channel, order, and overwrite state in one caller-retained manifest | Lead: additive structure, exact standard-role configuration, exact or receipt-bound role and channel chains, sparse exact channel metadata, and exact-channel one-target overwrites share one fixed sequence with broader guild domains | Covered: a compact blueprint directly covers roles, categories, six channel types, role order, and known-role channel overwrites, but existing channel order remains outside reconciliation | Covered: one blueprint spans guild fields, roles, categories, channels, overwrites, and starter messages; one live snapshot produces an action list that one apply call can execute |
| Target selection for an existing role or channel | Lead: exact snowflake only, separately allowlisted, duplicate rejected before planning, and stable across canonical array reordering | Partial: names select resources, and duplicate live roles warn while the first match wins | Partial: stored tracked IDs take precedence, but a missing or stale binding falls back to the first same-name resource of the expected type |
| Omitted desired fields remain unmanaged | Lead: strict sparse domain schemas preserve omitted fields and reject inapplicable or unknown intent | Covered: omitted modeled fields are unmanaged | Partial: omitted modeled fields are generally preserved, but position, parent, metadata, and complete overwrites can share one combined channel action |
| Exact role permission convergence under future Discord bits | Lead: replaces only the known permission set, preserves unknown future bits, and rejects ADMINISTRATOR | Partial: replaces the complete computed bitfield from the source-head permission catalog; bundled templates include ADMINISTRATOR roles | Partial: replaces the complete computed permission bitfield when present and has no blueprint-level ADMINISTRATOR prohibition |
| Existing role ordering inside the manifest | Lead: a unique top-to-bottom chain resolves only exact or receipt-bound scaffold roles, converges adjacent pairs bottom-up through one fresh frontier, and proves complete hierarchy and holder impact before each move | Covered: reconcile mode bulk-orders blueprint roles by name in the same apply plan | Not covered: the blueprint role schema has no order field; a separate bulk tool accepts caller-selected numeric positions |
| Existing channel ordering inside the manifest | Lead: globally unique exact or receipt-bound top-to-bottom chains converge bottom-up with one fresh target-and-anchor frontier, explicit cross-parent acknowledgement, complete affected groups and capacity, movement authority, exact overwrite preservation, one non-retried write, and newer Gateway plus HTTP readback | Partial: creation assigns numeric positions, but reconcile does not reposition existing channels and directs operators to the separate bulk reorder tool | Covered: numeric position and symbolic categoryKey can update an existing channel, but the same name-fallback action can combine order, parent, metadata, and complete-overwrite effects without a complete affected-group or dual-source readback boundary |
| Existing channel permission-overwrite convergence inside the manifest | Lead: one exact separately allowlisted direct channel and exact member or exact or receipt-bound role target per frontier, named deltas or deletion, unrelated-target preservation, complete continuity evidence, and exact readback | Covered: reconcile mode converges known blueprint-role overwrites by role name and preserves member and unrelated-role overwrites | Partial: a channel or category action can replace the complete requested overwrite set through symbolic keys or IDs, but it shares name fallback and the combined-action review and readback boundary |
| Whole-manifest preview and live-state honesty | Lead: one credential-free local tool strict-normalizes and returns the complete ordered intent, direct dependencies, exact and scaffold references, and possible stages without the raw key or authority; every live plan overlays all entries as freshly assessed or deferred and identifies only one executable frontier without inventing future IDs or post-write state | Covered: one dry run returns a complete ordered operation list against one live snapshot, but a single apply can execute that complete list without fresh post-write assessment between operations | Covered: a dedicated plan and apply dry run return the complete action list and snapshot-bound digests, but apply can execute every action from that initial plan without a fresh reviewed frontier between writes |
| Review and approval boundary | Lead: every write frontier gets a fresh keyed aggregate and domain plan, host approval, signed elicitation, and identical-input check | Partial: dry run is recommended, but one apply call may execute the complete plan without a signed per-operation review boundary | Partial: privileged whole-blueprint changes use one expiring payload-bound confirmation, while ordinary structure and ordering can execute without confirmation and neither path reviews each action separately |
| Failure and replay safety | Lead: one non-retried write per frontier, durable pending records, exact readback, spent keys, restart-safe matching receipt reconciliation, and quarantine after ambiguity | Partial: apply stops at the first reported failure and advises rerunning the diff; the shared client automatically retries network and server failures, including non-idempotent writes | Partial: a durable journal marks each action running, completed, or failed, but one call performs multiple writes and a later apply replans and can retry without exact uncertainty quarantine or post-write state proof |
| Recovery after a completed phase | Lead: a completed matching receipt can satisfy only fresh exact current state; later drift remains a spent-key conflict | Partial: rerunning recomputes a name-based diff without request-bound receipts or exact mutation provenance | Partial: persistent logical-key bindings and action history retain assigned IDs, but stale bindings fall back to names and completion is not conditioned on a fresh exact domain readback |
| Authority and blast-radius control | Lead: pinned application and bot, exact capability-specific scopes, complete permissions and hierarchy, target coordination, and no authority from the blueprint toolset itself | Partial: one token plus guild membership and broad Discord permissions govern the provisioner; the blueprint has no independent target policy | Partial: guild allowlisting, read-only, safe-write, and full modes bound broad authority, but there are no blueprint-phase or exact-target capability scopes and ordinary order changes share the broad apply gate |
| Persistent privacy and observability | Lead: the manifest and presentation fields stay transient while domain activity and receipts remain content-free | Partial: token-redacted JSON logging is documented, but no content-free per-operation durable recovery record is demonstrated | Partial: persistent state and journals retain logical resource keys, IDs, action history, and sanitized errors rather than a content-free domain receipt with explicit field exclusions |
| Deterministic starter designs and server-building guide | Lead: four versioned public-only community, creator, project, and support starters compile locally through the production strict request normalizer, emit symbolic category and per-parent ordering, and expose purpose, design principles, omissions, policy requirements, and exact-ID hardening without Discord contact or authority; the narrower recipe requests no Manage Roles | Covered: four templates and a design guide are easy to discover, but bundled roles include ADMINISTRATOR, private and read-only claims depend on broad overwrite application, and their template objects belong to the same broad applying blueprint model | Partial: one detailed example demonstrates categories, six channel types, positions, overwrites, settings, and presentation, but there is no finite versioned starter catalog or authority-free compiler review contract |
| Local transport and packaged setup fit | Lead: local stdio, pinned package and native binary paths, MCPB, OCI image, generated model-neutral adapters, offline validation, and guided activation preserve operator-owned credential custody | Partial: stdio and optional bearer-protected Streamable HTTP are available, but the broader transport changes custody and deployment assumptions | Partial: local stdio preserves bot-token custody, but the blueprint surface and persistent state remain part of one broader all-in-one installation rather than a least-privilege starter profile |
GuildControl MCP leads every safety and supported convergence row in this focused comparison. Local-only transport remains a deliberate custody boundary rather than a claim that remote bearer deployment is equivalent. Blueprint channel ordering is now an integrated exact or receipt-bound phase; capture still omits inferred ordering, and parent-category permission synchronization remains a separate reviewed workflow. TinyGecko's name-based matching, first-duplicate selection, broad partial apply, and automatic retry model are not suitable shortcuts for the same outcomes. Its serial apply loop, retrying REST client, and template catalog make each tradeoff independently inspectable. TheETR's blueprint engine, example manifest, and standalone bulk ordering tools likewise expose its numeric-position, name-fallback, journal, and combined-action tradeoffs directly.
Destructive recovery-preparation head-to-head
Section titled “Destructive recovery-preparation head-to-head”TheStreamCode supplies the strongest adjacent recovery design found in the source-head audit. Its safety guard makes a backup ID or explicit no-backup override part of destructive requests, while its backup store, schema, tools, and limitations define a persistent snapshot, diff, and conservative restore workflow. GuildControl MCP adopts the valuable forced-choice outcome but defines recovery preparation as short-lived evidence for one exact irreversible target, not as a complete server backup or automatic rollback system.
| Recovery-preparation outcome | GuildControl MCP | TheStreamCode source head |
|---|---|---|
| Require an explicit captured-artifact or no-artifact choice before channel and role retirement | Lead | Partial: destructive tools accept a backup ID or explicit override, but the backup need not prove the exact target |
| Bind verified application, bot, guild, target kind, and exact target ID | Lead | Partial: validates the source guild, not the application, bot, target kind, or exact target |
| Match a fresh current target projection before planning and again at every deletion freshness boundary | Lead | Not demonstrated |
| Expire evidence after a fixed short lifetime and invalidate it on process restart | Lead | Not demonstrated |
| Present capture fingerprint, target projection, omission codes, and fixed limitations for review | Lead | Partial: stores a structured snapshot and documents broad restore limits |
| Keep Discord content and presentation out of connector-owned persistence | Lead | Not demonstrated: the JSON snapshot intentionally stores names, topics, permissions, policy, and presentation state |
| Bind the deletion plan and signed confirmation without returning or persisting the raw attestation | Lead | Not demonstrated |
| Bind non-backup limitations into exact target review without treating recovery evidence as deletion authority | Lead | Partial: restore losses are documented, but they are not bound into an exact target-fresh deletion review |
GuildControl MCP leads the narrower safety outcome: preparing explicit, fresh, exact-target, privacy-preserving evidence before retirement. TheStreamCode leads when the desired outcome is automatic application of a stored lossy snapshot. That is a real feature difference, not a missing checkbox. Adding restore would require a separate authority, persistence, conflict, failure, and verification design and is not implied by these attestations.
Live conversation-recall head-to-head
Section titled “Live conversation-recall head-to-head”blackgirlbytes supplied the strongest direct recall idea in its tool contract and Discord service: derive several likely phrases from a vague memory, search each through Discord relevance, deduplicate candidates, and rank phrase coverage before reciprocal rank. GuildControl MCP adopts that useful operator outcome and makes fresh verified context, exact policy, and non-persistence part of the same read contract. The focused rubric defines success as finding and safely reconstructing one vaguely remembered live conversation, not as building a research database.
| Live recall outcome | GuildControl MCP | blackgirlbytes source head | Cappyeo 0.25.0 |
|---|---|---|---|
| One exact permitted guild with optional exact channel, author, and timestamp bounds | Lead | Partial | Partial |
| Freshly pinned application and bot identity before search | Lead | Not demonstrated | Partial |
| One to five bounded distinct literal phrase variants | Lead | Covered | Not demonstrated |
| Official Discord relevance search rather than a recent-page substring scan | Lead | Covered | Not demonstrated |
| Deterministic duplicate fusion by phrase coverage, reciprocal rank, recency, and exact ID | Lead | Covered | Not demonstrated |
| Content-free whole-call indexing response that discards earlier partial candidates | Lead | Partial | Not demonstrated |
| Bounded current context automatically returned for every ranked target | Lead | Partial | Not demonstrated |
| Exact indexed-target snapshot matched against the fresh context read | Lead | Not demonstrated | Not demonstrated |
| Cross-guild, cross-channel, duplicate, malformed, changed, and age-restricted evidence rejected as a whole | Lead | Partial | Partial |
| Search phrases represented only by one-based indexes in results | Lead | Not demonstrated | Not demonstrated |
| Usernames, profile names, channel names, and raw payloads omitted | Lead | Not demonstrated | Not demonstrated |
| No connector-owned message archive, embedding index, cache, or content record | Lead | Partial | Covered |
| One standard MCP tool with truthful read-only annotation, discovery, exact-guild completion, and a dedicated prompt | Lead | Partial | Partial |
| Explicit literal-search, approximate-index, bounded-context, and stale-target limitations | Lead | Partial | Partial |
GuildControl MCP's live recall contract performs the complete retrieval and current-context verification in one cancellable call. If Discord reports indexing for any phrase, no match from another phrase escapes. Phrase text is input-only, while returned context contains the minimum exact identities and current message evidence needed to explain a match. The connector still returns message content to the caller because recall cannot work without it, but it never stores that content and never markets literal phrase search as semantic retrieval or complete history.
Multi-channel message catch-up head-to-head
Section titled “Multi-channel message catch-up head-to-head”cael-agent's source-head check_new_messages and preview_discord provide the strongest direct catch-up idea found in the wider scan: scan one configured guild's readable text channels, summarize new messages, retain per-channel high-water marks, suppress automated noise in the compact preview, and use exact message IDs for follow-up. Its high-water store makes repeated use especially convenient for one persistent project. GuildControl MCP preserves the one-call outcome while moving selection and continuation state back to the caller and proving that a full forward page can advance without losing an unseen middle segment. This focused comparison uses source-head idea evidence rechecked on 2026-08-29 and remains outside the versioned release score.
| Multi-channel catch-up outcome | GuildControl MCP | cael-agent source head |
|---|---|---|
| One bounded call across channels | Lead: one exact guild plus a caller-ordered bounded set of unique exact channel or thread IDs, with a complete request-wide scan ceiling | Covered: scans one configured guild's visible text channels or one name-or-ID target, excluding the logs channel, with a per-channel fetch ceiling |
| Target scope before message access | Lead: exact local guild and channel policy is enforced before any message endpoint, with no name resolution or implicit all-visible selection | Partial: one configured guild bounds the operation, while an omitted channel expands to every fetched visible text channel and a supplied name can resolve through a local map |
| Identity, intent, and permission evidence | Lead: pinned application and bot, authoritative Message Content intent, exact channel and thread-parent identity, private-thread connector membership, complete roles and overwrites, and effective read permission are all required before any message page | Partial: discord.js access determines what can be fetched, but the catch-up runtime does not demonstrate an equivalent pinned application, complete intent, role, overwrite, parent, membership, and permission preflight contract |
| Cursor custody and persistence | Lead: each next cursor is explicit caller state; the connector stores no cursor, inbox, content, channel, author, or profile data | Different fit: channel high-water maps are stored in local JSON files and a message-to-channel cache supports later ID-only reads |
| First-call honesty | Lead: cursor-free selection is named initialize, reports whether older messages may exist, and never claims unread or complete history | Partial: first use returns a recent per-channel window and describes it as the last messages, but persistent state makes that baseline implicit to the connector |
| Full forward-page continuity | Lead: an independent one-message boundary probe must match the oldest full-page item before the next cursor advances; contradiction rejects the whole call | Partial: advances to the newest fetched ID without an independent boundary proof or an explicit more-newer-traffic result |
| Human-message omission safety | Lead: the scan ceiling is also the chronological page boundary, so every scanned human message is returned; default-hidden bot and webhook traffic is separately counted and deliberately advances coverage | Partial: compact preview retains only the newest bounded human subset from a larger fetched page, reports the human and bot totals, and advances the stored cursor beyond human messages omitted from the body |
| Cross-channel failure semantics | Lead: every selection is preflighted and every page must validate; any failure yields no partial channel result or cursor map | Partial: channel resolution and message-fetch failures are caught per channel and skipped, allowing a partial successful response without an explicit failed-channel set |
| Privacy projection | Lead: short Unicode-safe previews, exact IDs and timestamps, structural counts, and bot, webhook, system, connector, mention, reply, and edit evidence omit usernames, profile names, attachment names and URLs, rich bodies, and raw payloads | Partial: compact output includes channel names, usernames, previews, reply usernames, and attachment presentation; the broader check routes text through a project-specific formatting sidecar, while the preview deliberately bypasses it |
| Automated-message handling | Lead: bot and webhook messages are omitted by default but included in scanned and omitted counts, cursor advancement, boundary verification, and an explicit opt-in projection | Covered: preview suppresses bot and webhook bodies, reports their count, and advances its high-water mark through them |
| Exact detail follow-up | Lead: every visible item carries exact guild, channel, message, and author IDs plus a canonical jump link; get_message remains a separately user-directed exact read under the same policy | Covered: message IDs enter a process-local channel cache so read_message can omit its channel argument for recently seen messages |
| MCP discovery and one-shot guidance | Lead: a canonical read-only tool has exact readiness metadata, progressive discovery, observability risk, strict structured output, and a policy-aware prompt that emits machine-copyable next cursors and forbids hidden reads, loops, Gateway use, persistence, or writes | Partial: ordinary tool descriptions make both catch-up routes easy to find, but no equivalent prompt, access contract, partial-result warning, or caller-cursor handoff is demonstrated |
GuildControl MCP deliberately does not copy implicit all-visible scans, name-based selection, connector-owned high-water files, or ad hoc timestamp substitution inside the repeatable cursor contract. Those are concise conveniences for a fixed project, but they make exact reviewed scope and continuity harder to distinguish. One-off time-bounded investigation remains a search outcome; repeatable catch-up starts with an explicit baseline and continues only through each channel's returned exact message ID.
Command-bound processing-feedback head-to-head
Section titled “Command-bound processing-feedback head-to-head”MADPANDA3D supplied the strongest direct endpoint idea in its v1.1.1 typed operation registry, which exposes trigger_typing through its generic confirmed write tool and proves that writes are not retried in its REST tests. The focused rubric follows Discord's typing-indicator contract: bots generally should not call it, except to acknowledge a command whose processing is expected to take several seconds.
| Command-processing feedback outcome | GuildControl MCP | MADPANDA3D 1.1.1 |
|---|---|---|
| Dedicated operator intent limited to expected multi-second command processing | Lead | Partial |
| One exact target channel and initiating source message | Lead | Not demonstrated |
| Freshly pinned application and bot identity plus exact local interaction scope | Lead | Partial |
| Ordinary non-bot, non-system, non-webhook regular or reply source | Lead | Not demonstrated |
| Timestamp and snowflake creation consistency inside a fixed fresh-source window | Lead | Not demonstrated |
| Verified bot direction in both parsed mentions and literal message content | Lead | Not demonstrated |
| Supported active channel or thread state with exact parent and private-thread membership evidence | Lead | Not demonstrated |
| Complete bounded role and overwrite inventory with effective read and send permission proof | Lead | Not demonstrated |
| Dedicated strict MCP schema and truthful non-idempotent write annotation | Lead | Partial |
| Source-bound concurrent and repeat-call coalescing | Lead | Not demonstrated |
| Shared rolling anti-spam budget without delaying the durable response cooldown | Lead | Not demonstrated |
| Pending and terminal content-free activity with sanitized failures | Lead | Partial |
| One bodyless non-retried POST with exact 204-only success | Lead | Partial |
| Minimal content-free result with explicit local replay and ten-second expiry semantics | Lead | Not demonstrated |
| Explicit no-readback and restart-reissue limitation | Lead | Not demonstrated |
GuildControl MCP's command-bound signal turns the raw endpoint into a narrow acknowledgment of one proven user intent. It never acts as arbitrary presence, a progress loop, completion evidence, or a remote wait primitive. One process coalesces the exact fresh source; a restart may repeat the transient signal, which is why the MCP contract does not claim idempotence. The implementation preserves MADPANDA3D's useful non-retry behavior while accepting only Discord's exact empty success and keeping source content, mentions, profiles, permission evidence, and response details out of results and durable state.
Exact attachment-consumption head-to-head
Section titled “Exact attachment-consumption head-to-head”LawyerCord supplied the strongest native-content idea: its MCP result adapter emits image and audio blocks after an exact attachment download, while its native delivery bridge bounds a streamed fetch and writes it into a private downloads directory. rayenking's attachment tool accepts a caller-supplied CDN URL and returns a temporary path. The focused rubric defines the operator outcome as safely bringing one exact current Discord attachment into MCP context, not as maintaining a connector-owned download archive.
| Exact attachment-consumption outcome | GuildControl MCP | LawyerCord source head | rayenking source head |
|---|---|---|---|
| One exact channel, message, and attachment selection | Lead | Covered | Not demonstrated |
| Exact local read scope plus freshly pinned application and bot identity | Lead | Partial | Not demonstrated |
| Fresh exact-message lookup before every delivery | Lead | Covered | Not demonstrated |
| No caller-supplied URL, filename, path, MIME type, or byte body | Lead | Covered | Partial |
| Fixed signed CDN origin with exact path identities, decoded filename, query set, timestamps, and signature shape | Lead | Partial | Partial |
| Credential-free, no-referrer, no-cache, non-redirected, non-retried delivery request | Lead | Partial | Partial |
| Streaming bounded by current Discord size and the MCP response budget with exact byte-count completion | Lead | Partial | Not demonstrated |
| Declared and delivered media agreement plus supported native byte-signature verification | Lead | Partial | Not demonstrated |
Safe application/octet-stream embedded fallback for unsupported or absent native media types | Lead | Partial | Not demonstrated |
| Native MCP image or audio block plus equivalent stable private resource | Lead | Partial | Not demonstrated |
| No connector-owned download file or local path disclosure | Lead | Different fit | Different fit |
| Signed URL and raw payload omitted from results, errors, logs, traces, and durable state | Lead | Partial | Partial |
| Raw-secret scan before encoding and byte wiping on success or failure | Lead | Not demonstrated | Not demonstrated |
| Fixed actionable failure classes without URL, response, or transport-cause disclosure | Lead | Partial | Partial |
| Standard MCP tool, resource, discovery, completion, and host-compatibility guidance | Lead | Partial | Partial |
GuildControl MCP's native exact message-attachment reader adds no capability flag, storage root, environment variable, write authority, Gateway dependency, or persistence path. It refetches current message evidence and internally consumes Discord's signed delivery capability without ever exposing or accepting that capability at MCP. The result uses the official MCP image, audio, embedded blob, and resource-link content types, while the delivery boundary follows Discord's attachment object and signed attachment CDN URL contract. A host that does not support rich or binary MCP content remains an explicit compatibility limitation, and an operator who wants a persistent inbox should choose that different custody model rather than treating transient consumption as a download manager.
Guild vanity audit head-to-head
Section titled “Guild vanity audit head-to-head”HardHeadHackerHead's vanity handler checks the guild feature and returns the code, full URL, and usage count. arrrnmp's typed guild-settings service applies its guild allowlist and returns the endpoint's code and usage count. glittercowboy's direct handlers expose both the read and an immediate PATCH. The focused rubric follows Discord's public Get Guild Vanity URL contract, which requires MANAGE_GUILD, returns a nullable code plus usage count, and documents no vanity mutation route.
| Vanity-audit operator outcome | GuildControl MCP | HardHead source head | arrrnmp source head | glittercowboy source head |
|---|---|---|---|---|
| Documented read with an exact selected guild | Lead | Partial | Covered | Partial |
| Exact local scope plus freshly pinned application and bot identity | Lead | Not demonstrated | Partial | Not demonstrated |
Complete owner or MANAGE_GUILD evidence before disclosure | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| Feature-aware endpoint eligibility without masking unrelated failures | Lead | Partial | Not demonstrated | Not demonstrated |
| Strict bounded response projection and unknown-field accounting | Lead | Not demonstrated | Partial | Partial |
| Guild-object and endpoint-code consistency check | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| Code omitted by default and disclosed only through explicit strict input | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| No full invite URL in the MCP result | Lead | Not demonstrated | Covered | Covered |
| Always-redacted exact-guild MCP resource and progressive discovery | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| Explicit no-persistence, no-log, no-trace, and content-safe error boundary | Lead | Not demonstrated | Not demonstrated | Not demonstrated |
| Documented-only mutation boundary | Lead | Covered | Covered | Partial |
| Deterministic tests for eligible, ineligible, redacted, disclosed, malformed, drifted, and failed reads | Lead | Not demonstrated | Partial | Not demonstrated |
GuildControl MCP's privacy-bounded vanity audit reuses the existing invite-audit capability and exact guild scope. It skips the endpoint for an ineligible guild, validates the documented feature and both independent code observations, returns only eligibility, configuration state, uses, permission evidence, and count-only unknown fields by default, and never constructs a URL. Explicit includeCode: true disclosure remains transient, while the exact-guild resource always forces redaction. The implementation deliberately adds no vanity write from private or inferred API behavior.
Native poll decision-lifecycle head-to-head
Section titled “Native poll decision-lifecycle head-to-head”Timergy 0.1.4 contributes a notably clear product idea: its MCP instructions lead an operator through create, share, collect, inspect, and finalize stages instead of exposing five unrelated tools. The exact Registry release resolves to the @timergy/mcp 0.1.4 package, whose included TypeScript source was audited. GuildControl MCP adopts that guided lifecycle for native Discord polls while retaining its local credential, exact-scope, review, privacy, and recovery model. The focused rubric is one poll whose participants already belong in Discord; Timergy remains the stronger different-fit choice when the actual need is a scheduling website for participants outside Discord with structured yes, maybe, and no availability.
| Native Discord poll outcome | GuildControl MCP | Timergy 0.1.4 |
|---|---|---|
| Guided create, observe, and finalize journey | Lead: three policy-aware prompts validate creation, make one aggregate inspection, and review ending through the matching native tools | Covered: server instructions explicitly sequence create, share, results, and finalize across five tools |
| Participant experience | Lead: participants vote on the native message inside the exact Discord channel without a connector-issued credential | Different fit: participants follow a Timergy URL and vote through the separate service |
| Connector credential and data custody | Lead: the process owns only its Discord bot token; poll text stays transient and no voter credential exists | Partial: the configured API receives scheduling and participant data; creation returns an admin passphrase and the MCP process retains it plus per-name voter tokens |
| Target identity and authority | Lead: pinned application and bot, exact guild and channel scope, supported channel state, complete roles and overwrites, and exact permissions | Not demonstrated for Discord: the service targets a Timergy poll UUID rather than a verified Discord application, bot, guild, or channel |
| Creation review and mutation boundary | Lead: immutable content and settings receive a fresh keyed plan, host approval, signed confirmation, durable one-shot reservation, one non-retried create, and exact response plus message readback | Partial: create_poll performs one immediate third-party write and returns the passphrase with no separate reviewed plan or post-write readback contract |
| Result semantics | Lead: one exact read distinguishes unknown, approximate, and final counts, preserves non-sequential answer IDs, and reports future fields without inventing zeroes | Covered: separate metadata and result tools expose option IDs and named availability, but the MCP adapter does not define equivalent future-field or approximation evidence |
| Voter privacy boundary | Lead: aggregate inspection fetches no identities; separately gated voter audit returns bounded IDs only and persists nothing | Partial: voting accepts a name and optional email, result rendering returns voter names, and process memory keys voter tokens by poll ID plus name |
| Finalization review | Lead: the bot-owned exact poll, complete structure, live counts, ownership, lifecycle, future fields, and permissions bind an irreversible plan; any vote change invalidates review | Partial: finalization accepts a caller-selected option and a supplied or remembered passphrase, exchanges it for an admin token, and performs the write immediately |
| Ambiguity, retry, and recovery | Lead: non-retried writes, pending content-free evidence, spent keys, exact readback, durable target exclusion, and uncertainty quarantine | Not demonstrated: the adapter forwards API errors as text and documents session loss of the remembered passphrase, without an operation receipt, exact postcondition, or ambiguity quarantine |
| MCP discovery and host portability | Lead: standard tool discovery, three prompts, policy-aware exact-channel completion, static access contracts, progressive activation, and a model-neutral package | Covered: five ordinary tools, concise instructions, stdio, and hosted Streamable HTTP make the scheduling flow easy to find |
| Release identity and verification | Lead: cross-surface version checks, reproducible archives, SBOMs, provenance, package execution, and protocol evidence | Partial: the 0.1.4 package includes auditable source, but its runtime server metadata still reports version 0.1.1 and the release does not publish comparable verification evidence |
GuildControl MCP does not copy Timergy's bot-side voting, configurable service origin, passphrase channel, named voter-token map, or third-party retention model. Its three prompts add no endpoint, permission, capability flag, background task, state store, or execution shortcut. They improve the useful lifecycle idea by keeping every write on the existing reviewed native Discord path and keeping aggregate inspection identity-free by default.
Discord-native task-coordination head-to-head
Section titled “Discord-native task-coordination head-to-head”bookedsolidtech's source-head agent coordination guide supplies the strongest explicit Discord-as-a-human-visible-agent-bus design found in the wider scan. Its reply collector, reaction reader, native polls, thread guidance, project routing, optional personas, and directed note board turn ordinary Discord primitives into a coherent operator journey. GuildControl MCP implements both the exact-task and directed-note journeys while keeping exact policy, default aggregate privacy, guarded idempotent writes, and no connector-owned task or address state as first-class boundaries. This focused comparison uses source-head idea evidence rechecked on 2026-08-29 and remains outside the versioned release score.
| Human-visible coordination outcome | GuildControl MCP | discord-ops source head |
|---|---|---|
| Discoverable lifecycle | Lead: discord://connector/coordination publishes one versioned model-neutral static contract; inspect_discord_coordination_task and inspect_directed_discord_notes provide strict policy-aware one-shot reads; and the dedicated risk-separated toolset participates in exact access contracts, a least-privilege coordination-channel recipe, standard resources, prompts, tools, and progressive discovery | Covered: a notably clear standalone guide sequences ordinary tools, but the protocol is not exposed as an equivalent versioned MCP resource, exact readiness contract, dedicated toolset, or bounded inspection prompts |
| Task identity and routing | Lead: one exact channel or thread ID plus exact task message ID remains the durable key, while an optional random strict dca_ label adds caller-retained directed delivery without registration; direct local policy applies before Discord access and no address, alias, name, persona, tag, or task text grants authority | Partial: the returned message ID is retained as the key, while project and channel aliases provide ergonomic routing and broader persona and note tokens remain display conventions rather than authenticated identity |
| Directed note lifecycle | Lead: local credential-free address creation, body-free page-local sender observation, strict versioned directed or broadcast envelopes, exact sender and tag filters, optional unresolved-convention filtering, fixed aggregate status counts, honest cursors, and a one-shot recipient prompt add routing without a registry, retained content, or privileged intent | Covered: an ordinary Discord note board provides friendly recipient and session tokens, filters, recent-session discovery, reaction resolution, and owner notification, but reads and local listener state expose task bodies and display tokens without the same strict authorship, policy, minimization, cursor, or no-registry boundary |
| Direct-reply collection | Lead: verifies pinned application and bot identity, exact channel and source, strict response route and uniqueness, and only type-19 default references to that exact source; returns ascending replies, scan counts, limit state, and a caller-held exact cursor without persistence | Covered: fetches the anchor, scans after an exact cursor, filters discord.js Reply messages by reference, and returns scan progress, but does not demonstrate the same pinned identity, strict raw-response projection, direct exact policy, or privacy contract |
| Polling and continuation | Lead: performs exactly one bounded page per tool or prompt call, advances across valid unrelated traffic, exposes scanLimitReached, stores no cursor, and explicitly forbids timers, loops, automatic second pages, search substitution, and Gateway polling | Covered: recommends task-boundary polling, exact cursors, threads in busy channels, and escalation instead of tighter intervals, while allowing callers to continue the scan directly |
| Reaction status | Lead: ordinary inspection is aggregate-only, user enumeration is a separately disabled exact-channel gate, bot-own signals never authenticate sessions, conflicts remain ambiguous, and no count authorizes work | Partial: exposes user IDs, usernames, and bot flags by default and suggests using them to identify a peer, while separately acknowledging that personas and shared webhook display names are not authentication |
| Publication and reply writes | Lead: ordinary tasks and strict directed notes require stable idempotency keys, notifications are suppressed by default, a routing label never implies a mention, exact notification scope is reviewed separately, a shared anti-spam boundary applies, and response plus exact readback must match without echoing note content or routing values | Partial: ordinary and raw sends make the loop concise, but the coordination path does not demonstrate equivalent exact local scope, routing and notification separation, mention minimization, idempotent replay, pending evidence, or exact postcondition checks |
| Threads and structured consensus | Lead: longer exchange and native-poll guidance route through fresh keyed plans, signed host approval, durable exact coordination, non-retried writes, and exact readback; the inspection prompt recommends but never invokes them | Covered: immediate thread tools and a native-poll journey provide the same human-visible outcomes with lighter operational ceremony |
| Secrets and untrusted content | Lead: the playbook forbids secrets and private paths, every Discord string remains untrusted, no persona or name can select a protected action, and task content enters no connector store, event sink, diagnostic, or telemetry record | Partial: the guide clearly warns against secrets and confused-deputy behavior, while its optional listener writes watched content to a retained local sink and its note board parses durable task bodies and sender tokens from Discord messages |
| Cross-process and human visibility | Lead: Discord retains the exchange, exact caller-held IDs and opaque addresses bridge processes and harnesses, a separately allowlisted mention requests human attention, and bounded reads recover page-local routes without a connector task database or listener | Covered: project aliases, directed notes, session tokens, personas, owner notification, and an explicit worked multi-session protocol provide rich conventions, but optional retained listener and note-board state add connector-owned custody |
| Friendly aliases and personas | Different fit: clients may attach their own display labels to caller-retained addresses, but the connector deliberately accepts only exact Discord IDs and opaque routing labels and never stores an alias or persona registry | Lead for display convenience: project aliases, channel aliases, persona presentation, names, and recent-session tokens reduce caller bookkeeping for teams that accept their ambiguity and custody |
| Authority and execution boundary | Lead: the resource grants no authority, inspection is read-only, reaction signals are not approval, and every later operation must independently satisfy its exact tool policy and reviewed lifecycle | Partial: tool profiles and security guidance narrow the surface, but task text, reactions, notes, or a persona convention are not bound to an equivalent target-specific reviewed execution contract |
| Release and contract verification | Lead: deterministic protocol evidence, exact tool-access requirements, cross-surface metadata checks, reproducible npm and MCPB archives, OCI verification, SBOMs, and signed release automation cover the coordination additions with the rest of the product | Not demonstrated at an equivalent cross-surface depth |
GuildControl MCP intentionally does not add a persona registry, locally retained listener, connector-owned note index, background worker, timer, or autonomous executor. Directed delivery and optional exact owner notification are available without those facilities. Friendly project aliases and persona presentation remain an explicit client-side convenience tradeoff rather than connector identity or durable state.
Additive reaction-set head-to-head
Section titled “Additive reaction-set head-to-head”Danushkumar's linked public source contributes a useful convenience: one handler fetches an exact message and adds several caller-supplied reactions in order. The Registry's hosted 1.2.0 entry cannot be tied to a source revision, so this focused comparison uses the public reaction handler and input schema rechecked on 2026-08-29 as source-head idea evidence, not release-matching scored evidence.
| Additive own-reaction outcome | GuildControl MCP | Danushkumar source head |
|---|---|---|
| One discoverable multi-reaction call | Lead: add_reactions is a first-class exact MCP tool with ordinary and progressive discovery, static readiness, and complete annotations | Covered: add_multiple_reactions exposes one direct handler |
| Input bounds and complete validation | Lead: strict exact IDs plus two to ten emoji, existing Unicode or name:snowflake grammar, and full validation before target access or writes | Partial: channel and message IDs are strings and emojis is an array of strings without demonstrated minimum, maximum, emoji grammar, or uniqueness |
| Logical uniqueness | Lead: duplicate Unicode values and custom emoji aliases sharing one snowflake fail before mutation | Not demonstrated |
| Target authority | Lead: freshly pinned application and bot plus exact policy-authorized interaction channel or thread | Not demonstrated in the handler |
| Idempotence and request replay | Lead: bot-owned reactions are prechecked, satisfied items become journaled no-ops, and the identical ordered set safely converges after interruption | Not demonstrated: every listed item calls message.react |
| Pacing | Lead: every real write uses the bounded local interaction limiter while Discord's dynamic response behavior remains authoritative | Partial: the loop sleeps a fixed 300 ms after every reaction |
| Mutation boundary | Lead: each item has a pending content-free record, one idempotent PUT operation with exact 204 handling, and a fresh exact-message postcondition that re-proves the complete processed prefix | Partial: each item awaits discord.js message.react, but no independent pending record or exact readback is demonstrated |
| Partial failure and recovery | Lead: stop at the first item failure or prefix drift, report only the failed index or drift boundary plus verified counts, never compensate, and document identical-request recovery | Partial: an exception stops the loop, but no content-free progress or convergence contract is returned |
| Privacy and persistence | Lead: results, errors, activity, telemetry, and durable state omit emoji values, message content, authors, and profiles | Not demonstrated for the handler |
| Poll distinction | Lead: reaction sets are documented for acknowledgements, status markers, and small emoji menus, while native poll tools retain vote-specific state and privacy semantics | Not demonstrated |
GuildControl MCP keeps the useful one-call outcome but does not copy the unbounded string array, unconditional writes, fixed sleep, or success-only summary. The feature adds no capability flag, scope, credential, endpoint, Gateway dependency, activity kind, or persistence path; it composes the existing exact-scope interaction primitive into a bounded recovery contract.
Audited releases and source limits
Section titled “Audited releases and source limits”| Product | Registry release | Audit basis | Scope note |
|---|---|---|---|
| GuildControl MCP | Repository revision containing this page | Reference, security policy, release runbook, production contract evidence, tests, and workflows | General-purpose owner-managed local stdio server; npm, OCI, and MCPB distributions |
| Cappyeo | 0.25.0 registry record | Tagged source | General-purpose local stdio package with optional HTTP and Gateway behavior |
| PaSympa | 2.1.1 registry record | Tagged source | General-purpose local stdio server distributed through npm and OCI |
| Hypark | 0.1.1 registry record | Tagged source | Focused local REST server distributed through npm, PyPI, OCI, and MCPB |
| Oratorian | 1.1.4 registry record | Tagged source | General-purpose local stdio or HTTP server with direct administration tools |
| Jaimen Bell | 0.1.1 registry record | Exact PyPI release and matching public source | Focused local REST server with a default-off write group; no source version tag was published |
| Targeted Reader | 1.0.0 registry record | Version-matching public source | Narrow local reader plus direct message posting; the registry record declares no installable package or remote endpoint and no source version tag exists |
The tagged audits use the exact public source tags named above. For untagged releases, the table states the weaker source basis explicitly. Source inspection does not prove how an undeclared private deployment is configured, and the matrix does not award unpublished controls.
Registry matches outside the scored local comparison
Section titled “Registry matches outside the scored local comparison”| Registry entry | Classification | Why it is not scored |
|---|---|---|
| Danushkumar 1.2.0 | Different fit | The registry exposes a hosted authenticated remote. Its linked repository does not identify source matching the registered release, so local custody and exact released behavior cannot be scored reliably; the public source head's multiple-reaction idea is compared separately above. |
| Sachicali suite 1.2.0 | Not auditable | The registry exposes a hosted authenticated remote and no public source repository. |
| mcp-dir 0.1.0 | Not auditable | The registry exposes a hosted remote. The public repository contains documentation and manifests but not the server implementation. |
| Timergy 0.1.4 | Different fit | This is a scheduling-poll service used from chat interfaces, not a Discord guild-access server. Its strong guided lifecycle is adopted and compared separately through native Discord polls. |
Maintenance rule
Section titled “Maintenance rule”The comparison is a release artifact, not a permanent boast. Refresh the registry snapshot and tagged-source audit before changing a score or publishing a release that repeats the field-lead claim, then run npm --prefix site run test:evidence-links. That high-cost check verifies every cited external source and requires an exact latest version record in the explicit release-classification tables for every non-self result in the official Registry's complete current Discord search, including different-fit and not-auditable entries. A new result, version change, stale record, duplicate, malformed page, or pagination defect fails with an actionable coverage error instead of silently narrowing the field. If a competitor demonstrates a stronger meaningful outcome, record that lead as a product gap, improve the product, and change the matrix only after the improvement is verified. Do not add a cosmetic category to preserve a perfect row.
Canonical source: docs/comparison.md
Documentation generated for guildcontrol@0.0.0. Canonical source and edit history remain in the public repository. GuildControl is an independent project and is not affiliated with or endorsed by Discord Inc. Discord is used only to identify the platform that GuildControl connects to.