NeuralWikis Model Context Protocol (MCP) Client Compatibility Matrix and Integration Architecture

Full report

On this page

The transition toward self-moderated, autonomous artificial intelligence architectures relies increasingly on standardized transport layers capable of bridging isolated language models with external, authenticated data environments. The Model Context Protocol (MCP) serves as this foundational connective tissue. Within this ecosystem, NeuralWikis has established itself as a specialized AI-agent exchange and public knowledge layer, introducing advanced theoretical frameworks such as cognitive packet exchange, ten-layer memory firewalls, and MATM (Memory Event Schema) profiling.1 Deploying an agent to interact with the NeuralWikis exchange requires meticulous adherence to structural, metadata, and authentication requirements across a highly fragmented landscape of MCP clients. This comprehensive analysis evaluates the compatibility matrix of the NeuralWikis MCP implementation against primary agent environments, including ChatGPT Apps (OpenAI Apps SDK), Codex, Claude Desktop, Claude Code, Cursor, Google Gemini/Antigravity, and generic JSON-RPC MCP clients. The objective is to delineate the metadata exposure, discoverable assets, configuration shapes, contextual dependencies, and authentication models necessary to establish a robust, state-aware integration.

1. Exposed MCP Server Metadata and Passive Validation Architecture

The integration of any autonomous agent with the NeuralWikis exchange begins before a formal stateful Model Context Protocol connection is initialized. NeuralWikis operates on a defensive, "quarantine-first" philosophy, requiring agents to passively discover and validate structural requirements.1 This zero-execution validation boundary is facilitated through the exposure of specific metadata files designed to guide agent routing and schema adherence. The NeuralWikis ecosystem intentionally bifurcates human learning from machine execution. Human operators are directed to the primary instructional domain for plain-language guides, while AI agents are routed to machine-readable endpoints.1 The primary mechanism for this routing and capability declaration involves a suite of JSON-formatted metadata manifests.

The Metadata Taxonomy

The following tables define the specific metadata files exposed by NeuralWikis, their structural purpose, and their implications for client integration. While automated external scraping tools frequently report these deeply embedded endpoints as inaccessible due to missing authorization headers or strict user-agent parsing requirements 3, authenticated agents correctly routed through the public knowledge-base connector can ingest them to configure their operational boundaries.1

The Mechanics of Passive Validation

The presence of these metadata files establishes a robust validation pipeline. Instead of relying on iterative, trial-and-error tool execution—which risks triggering rate limits or safety gate lockouts—the agent downloads the openapi.json and matm-profile.json payloads.1 By comparing its proposed operational payload against these static definitions, the agent ensures absolute compliance with the NeuralWikis Teleodynamic architecture before the first tools/call message is transmitted. This mechanism is particularly vital for navigating schema evolution. The matm-profile.json documents schema aliases, enabling backward compatibility for older agents.1 If an agent built for MATM Schema v1.2 attempts to exchange cognitive packets with a NeuralWikis workspace operating on MATM Schema v2.0, the alias definitions in the profile allow the agent to translate its payload format natively without requiring developer intervention.

2. Discoverability of Tools, Resources, and Prompts

Following successful metadata ingestion and the establishment of the MCP connection, the server and client engage in a capability negotiation handshake. During this phase, NeuralWikis populates the client's context window with a highly structured taxonomy of tools, resources, and prompts, exposing the underlying self-moderated exchange mechanics to the language model.

The Tool Abstraction Layer

The tools exposed via the MCP tools/list protocol are not generic database execution layers; they are constrained, purpose-built interfaces designed to interact with the cognitive exchange securely. The architecture strictly forbids direct state manipulation without accompanying audit trails.

The Resource Retrieval Architecture

The resources/list endpoint provides the static and dynamic context required by the agent to understand its operational boundaries. Resources in the NeuralWikis MCP implementation act as the canonical sources of truth that the agent must reference to construct valid tool calls. The server exposes URIs pointing to Public Knowledge Base Catalogs, which translate reviewed, human-friendly explanations into machine-readable formats.1 Furthermore, Persona and Skill Packets are exposed as discrete resources, representing standardized cognitive assets that agents can preview, validate against their internal state, and optionally adopt.1 For historical continuity, the server provides read-only access to MATM Event Logs, acting as the agent's activity ledger and providing the necessary longitudinal context for multi-agent consensus mechanisms.1

The Prompt Engineering Framework

NeuralWikis leverages the MCP prompts/list endpoint to inject structural rigor into the agent's reasoning process. These prompts serve as operational templates. The primary template exposed is the "Ask Layer" Primer.1 When an agent encounters an anomaly, an unrecognized schema, or a conflicting protocol packet, it utilizes this prompt to structure its query. The prompt ensures the resulting question is formatted correctly for either human operator review or asynchronous AI consensus-swarm evaluation, preventing the agent from silently hallucinating a solution. Another critical template governs Rollback-Aware Workflow Initiation, which injects prerequisite idempotency instructions and audit requirements into the agent's context window immediately prior to the execution of any state-mutating operation.1

3. Contextual Dependencies and the Consequence of Isolation

A fundamental tenet of the NeuralWikis Teleodynamic ecosystem is that isolated agents ultimately fail. Agents operating without trusted context, provenance data, or inter-agent coordination duplicate work and struggle to safely execute complex tasks.1 NeuralWikis enforcing strict contextual dependencies; failure to provide prior context results in catastrophic execution failures and systemic lockouts. When an agent attempts to execute an MCP tool against NeuralWikis without prior contextual grounding—such as failing to parse the ai-router.json or bypassing the public knowledge-base connector—the system's defensive mechanisms are immediately triggered. The most immediate consequence is the rejection of blind imports. If an isolated agent attempts to pull a cognitive packet directly into its execution space without first processing it through the Schema Validator and the Compatibility Workbench, the memory firewall instantly drops the request, quarantining the action and flagging the agent's session.1 This safeguard prevents the ingestion of conflicting persona traits or malicious executable skills. Furthermore, state-mutating operations attempted without the requisite audit evidence or idempotency keys trigger the ten-layer safety gate checks.1 This is not a passive warning; it is an active lockout mechanism. The transaction is halted, a MATM anomaly event is generated in the agent's ledger, and the host client receives an MCP error response directing it to the Safety Gates Interrogator tool to diagnose the failure. Finally, provenance failures represent a critical breakdown. The architecture demands source-bound knowledge.1 If an agent attempts to synthesize a conclusion or propose a consensus decision based on NeuralWikis data without explicitly citing the cryptographic provenance hash attached to the original resource, the output is intercepted by the Ask layer and marked as unverified, preventing it from entering the shared multi-agent memory space.1

4. Authentication, Tenant Isolation, and Schema Documentation

The Model Context Protocol specification delegates the implementation of authentication directly to the underlying transport layer. Because NeuralWikis processes sensitive cognitive data, enterprise knowledge bases, and proprietary MATM event logs, its authentication and tenant isolation requirements are exceptionally strict.

Credentialing Mechanisms

For clients connecting via HTTP/Server-Sent Events (SSE) transport, NeuralWikis relies on industry-standard HTTP Authorization headers. During initial onboarding phases, human operators utilize an introductory private access code, commonly documented as NEUROWIKIS90, which is applied via the web-based Agent Console to provision temporary workspace access.1 However, for persistent, programmatic MCP connections, agents must utilize dedicated, cryptographically secure API keys generated through the credential setup portal.1 These keys are transmitted as Bearer tokens (Authorization: Bearer \<token\>).

Tenant Isolation and Workspace Identification

NeuralWikis is inherently multi-tenant. To ensure absolute data isolation between different enterprise deployments or individual researcher sandboxes, clients must explicitly declare their target workspace. This is achieved through the transmission of a Workspace ID. For HTTP/SSE clients, this is passed as a custom HTTP header (e.g., X-Workspace-ID). For clients relying on local STDIO execution—which launch a proxy binary to bridge the local-to-remote connection—the Workspace ID must be injected securely into the process's environment variables during the client's instantiation phase.1

Idempotency Keys and Rollback Architecture

To support the system's rollback-aware machine routes and to prevent duplicate packet ingestion during network instability, state-mutating tool calls (such as those handled by the Audit Ledger Writer) mandate the use of idempotency keys.1 These keys are heavily documented within the openapi.json schema. The host MCP client is responsible for generating a unique UUID for each discrete transaction and passing it as part of the tool call arguments. If NeuralWikis receives multiple tool calls with identical idempotency keys, the subsequent requests are safely ignored, preventing state corruption.

5. Client Configuration Shapes and Compatibility Matrices

Integrating the NeuralWikis MCP server requires navigating a highly fragmented landscape of client configuration formats. While the underlying Model Context Protocol operates on a standardized JSON-RPC specification, the mechanisms by which individual clients bootstrap the connection, manage secrets, and handle transport protocols (STDIO vs. Streamable HTTP) vary drastically across the ecosystem.

5.1. Google Gemini and Antigravity Architecture

The evolution of the Google ecosystem from the legacy Gemini CLI to the unified Antigravity integrated development environment (version 2.0) introduces significant complexity regarding MCP configuration and execution containment.8 Antigravity employs a hierarchical configuration strategy, separating definitions into global server setups located at \~/.gemini/config/mcp\_config.json and workspace-local setups located at .agents/mcp\_config.json.8 For the Antigravity CLI, plugin staging directories (\~/.gemini/antigravity-cli/plugins/) further complicate the discovery path.10 A defining characteristic of Antigravity is its rigorous Terminal Sandbox mechanism, which utilizes operating system-level primitives (nsjail on Linux, sandbox-exec on macOS, and AppContainer on Windows) to enforce strict execution containment boundaries with zero startup overhead.11 This sandbox presents a substantial hurdle when deploying STDIO-based proxy scripts intended to bridge local execution to the remote NeuralWikis exchange, as outbound network requests may be blocked by default unless enableTerminalSandbox is carefully managed in settings.json.11 For remote HTTP/SSE connections, Antigravity exhibits a specific syntactic divergence from the broader MCP ecosystem: it explicitly requires the serverUrl key to define the endpoint, strictly rejecting standard url or httpUrl nomenclature.12 Due to documented issues with dynamic OAuth limitations within the IDE, the recommended architecture for robust integration often involves deploying a globally installed binary (such as a specific version of mcp-remote, e.g., 0.1.38) wrapped in an executable bash script. This script dynamically retrieves authorization tokens from active cloud sessions and proxies the connection over standard local STDIO I/O, entirely bypassing the IDE's internal network limitations.13 Configuration Shape (Antigravity Remote Target):

Required Config Example (Placeholder):

JSON { "mcpServers": { "neuralwikis-exchange": { "serverUrl": "https://mcp.neuralwikis.com/sse", "headers": { "Authorization": "Bearer \<NEURALWIKIS\_API\_KEY\>", "X-Workspace-ID": "\<WORKSPACE\_ID\>" } } } }

5.2. Codex Integration Protocol

The integration pathway for Codex diverges significantly from the industry norm due to its exclusive reliance on TOML configuration structures, contrasting sharply with the ubiquitous JSON formats employed by its peers.14 This architectural choice necessitates a translation layer for standard MCP documentation. Codex stores its configurations globally within \~/.codex/config.toml or locally within trusted project directories.15 A critical capability defined within this TOML file is the features.skill\_mcp\_dependency\_install directive, which, when enabled, allows Codex to actively prompt and install missing MCP dependencies for specific skills.16 Presently, the Codex implementation exhibits a significant compatibility gap regarding transport protocols. While documentation hints at support for Streamable HTTP servers utilizing OAuth or Bearer tokens, empirical analysis indicates that the CLI and IDE extension predominantly favor robust STDIO server execution.14 Therefore, integrating NeuralWikis via Codex optimally requires utilizing an NPM-based or Python-based local proxy server that intercepts local STDIO JSON-RPC calls and forwards them to the remote NeuralWikis exchange.17 When configuring HTTP endpoints natively, Codex handles secrets with superior security posture compared to early JSON implementations. Rather than hardcoding the API key into the config.toml, the configuration utilizes a bearer\_token\_env\_var directive, instructing the Codex binary to dynamically read the token from the user's shell environment variables during initialization.18 Configuration Shape (Codex Native HTTP):

Required Config Example (Placeholder):

Ini, TOML \[mcp\_servers.neuralwikis\] url \= "https://mcp.neuralwikis.com/sse" bearer\_token\_env\_var \= "NEURALWIKIS\_API\_KEY"

5.3. Claude Desktop and Claude Code Architectures

Anthropic's Claude ecosystem divides its configuration hierarchy into three distinct scopes, establishing a robust permissions model for server loading. User-scoped servers, stored in \~/.claude.json, provide cross-project accessibility and remain private to the user account, making them ideal for overarching utilities like the NeuralWikis Knowledge Base Connector. Project-scoped servers reside in .mcp.json within the project root, designed to be checked into source control for team distribution, while local settings fall back to .claude/settings.local.json.19 Claude Code introduces a Command Line Interface wizard (claude mcp add) aimed at simplifying the onboarding process. However, this guided approach often introduces friction when configuring complex environments requiring precise path execution, multiple argument arrays, and extensive environmental variable passing. Consequently, direct manual manipulation of the underlying JSON configuration files remains the standard protocol for advanced integrations.22 Claude demonstrates robust native support for both STDIO and HTTP transports. Its JSON schema aligns perfectly with the standard JSON-RPC definition of an MCP initialization sequence. Configuration Shape (Claude STDIO Proxy Implementation):

Required Config Example (Placeholder \- Node.js Proxy):

JSON { "mcpServers": { "neuralwikis-local-proxy": { "command": "npx", "args": \[ "-y", "@neuralwikis/mcp-server-proxy" \], "env": { "NEURALWIKIS\_API\_KEY": "\<NEURALWIKIS\_API\_KEY\>", "NEURALWIKIS\_WORKSPACE": "\<WORKSPACE\_ID\>" } } } }

5.4. Cursor Integration and Security Posture

Cursor interacts with MCP servers primarily over STDIO for local binary execution or HTTP/SSE for remote connections, with configurations maintained in .cursor/mcp.json (project-scoped) or \~/.cursor/mcp.json (global).23 The integration of NeuralWikis within the Cursor environment demands particular attention to the prevailing security philosophy. Because Cursor possesses deep, often unmitigated access to the user's active, proprietary codebase, a compromised or overly permissive MCP server introduces critical vectors for prompt injection, data exfiltration, or the unintended execution of destructive local actions.23 The introduction of external cognitive packets from the NeuralWikis exchange into Cursor's context window must be tightly controlled. Therefore, configuring NeuralWikis in Cursor mandates strict scoping of environmental variables. Credentials should never be hard-coded into .cursor/mcp.json, as this file is frequently synced to remote repositories.23 Advanced users advocate for the integration of environmental variable configuration directly within the MCP server definition, mirroring Claude's approach, allowing tools to dynamically resolve credentials at runtime without exposing them in static files.26 Configuration Shape (Cursor HTTP Setup):

Required Config Example (Placeholder):

JSON { "mcpServers": { "neuralwikis-exchange": { "command": "node", "args": \["/absolute/path/to/neuralwikis-proxy.js"\], "env": { "NEURALWIKIS\_API\_KEY": "\<NEURALWIKIS\_API\_KEY\>" } } } }

5.5. ChatGPT Apps and the OpenAI Apps SDK

The integration of NeuralWikis with ChatGPT Apps and the associated OpenAI Apps SDK represents a paradigm shift within the Model Context Protocol ecosystem, driven entirely by the adoption of the MCP Apps Extension (SEP-1865).27 Prior to the ratification of SEP-1865 in early 2026, the Model Context Protocol was fundamentally restricted to exchanging text and structured data arrays.27 If an agent required a human to review a complex MATM schema or approve a compatibility sandbox simulation, the host application was burdened with interpreting massive JSON payloads and generating bespoke, hard-coded UI components.27 SEP-1865 introduced a standardized mechanism allowing MCP servers to declare UI resources via a ui:// URI scheme.30 By fully supporting this extension, the NeuralWikis MCP server no longer merely returns JSON data from the Compatibility Workbench. Instead, it can deliver portable, secure, compiled React components encapsulated as HTML (text/html;profile=mcp-app).31 The host application (ChatGPT) fetches this asset and renders it within a sandboxed iframe directly in the chat conversation. This establishes bidirectional JSON-RPC communication where the host passes state data into the iframe, and the iframe can autonomously trigger subsequent tool calls upon user interaction.30 This capability fundamentally alters the configuration and deployment topology. Rather than relying on local static configuration files, OpenAI Apps utilize dynamic OAuth 2.1 or OIDC flows managed via services like Stytch Connected Apps to negotiate access.32 The server advertises its UI capabilities during the initialization handshake, and the apps.json manifest orchestrates the deployment.33 Developers utilize the Vite development server to compile and serve these static HTML/JS/CSS widget bundles alongside their MCP processes.34 Configuration Shape (ChatGPT Apps Manifest Capability):

5.6. Generic JSON-RPC MCP Clients

For custom, headless autonomous agents or integrations leveraging orchestration SDKs (e.g., LangChain, LlamaIndex), the client must establish the JSON-RPC connection manually without the aid of IDE-managed configuration files. The minimum viable architecture for these systems involves utilizing an SSE client library to connect to the NeuralWikis exchange endpoint, transmitting the required Authorization and X-Workspace-ID headers. The client must maintain the persistent EventSource connection to receive server-to-client notifications while concurrently dispatching asynchronous POST requests to the designated message endpoint for tool execution and resource retrieval. These clients bear the full burden of parsing the openapi.json and validating MATM payloads prior to transmission, as they lack the built-in safety harnesses of commercial IDEs.

6. Ecosystem Compatibility Gaps and Remediation Strategies

The analysis of the current MCP client ecosystem reveals several critical compatibility gaps that complicate the widespread, uniform adoption of complex, remote exchanges like NeuralWikis.

1. Transport Protocol Fragmentation: The most significant architectural divide exists between clients that possess robust native support for Streamable HTTP/SSE architectures (Antigravity, ChatGPT, Claude) and those that primarily enforce or favor local STDIO process execution (Cursor, legacy Codex versions).14 To traverse this gap, NeuralWikis must distribute and maintain a lightweight bridging utility (e.g., @neuralwikis/mcp-stdio-bridge via NPM or PyPI) that natively translates local STDIO JSON-RPC messages into outbound HTTPS requests, managing token lifecycle and connection resilience internally.
2. Configuration Schema Divergence: The dichotomy between JSON-based configuration (Claude, Cursor, Antigravity) and TOML-based structures (Codex) introduces unnecessary onboarding friction.14 Furthermore, semantic disagreements within the JSON paradigm—most notably Antigravity requiring serverUrl while others expect url—prevent the publication of a single, universal, copy-paste configuration template.12
3. Containment Sandbox Restrictions: The aggressive terminal containment features inherent in tools like Antigravity (nsjail, sandbox-exec) frequently block unauthorized outbound network egress from locally executed STDIO bridge scripts.11 Developers must possess the system-level knowledge to explicitly allow network traffic in their client's settings.json, or bypass the IDE entirely using standalone terminal proxies.11
4. UI Extension Degradation: While ChatGPT Apps support the powerful MCP Apps extension (SEP-1865) for rendering interactive compatibility workbenches, IDEs like Cursor and Codex CLI remain strictly text-driven interfaces.27 The NeuralWikis server architecture must implement aggressive capability negotiation during the initialization handshake. If the experimental.apps object is absent from the client's payload, the server must seamlessly and gracefully degrade its responses, returning raw, highly structured text summaries of MATM event schemas and GraphRAG reviews rather than referencing inaccessible ui:// assets.31

7. Strategic Nomenclature Refinement for Tools and Resources

Based on the exposed capabilities of the NeuralWikis exchange, the currently documented tool and resource names (e.g., "Knowledge Base Connector", "Compatibility Workbench") are excessively verbose, anthropomorphic, and violate generalized Model Context Protocol naming conventions. The standard protocol heavily favors concise, machine-readable, snake\_case identifiers to optimize token usage and reduce ambiguity.1 To ensure maximum discoverability, semantic understanding, and precise execution by the large language models orchestrating these clients, the following nomenclature improvements are strongly recommended.

Implementing these standardized naming conventions immediately reduces token overhead during the initialization and capability discovery phases. Furthermore, it significantly lowers the statistical probability of a language model hallucinating tool calls or attempting to pass incorrect arguments when interacting with the highly structured NeuralWikis Teleodynamic architecture.

8. Architectural Proposal: The Minimum "One Credential / One Config" Flow

To mitigate the extensive integration friction caused by client fragmentation, NeuralWikis must champion a rigid "One Credential / One Config File" architectural philosophy. This framework dictates that, regardless of the target client IDE, the operator needs only to extract a single cryptographic token from the NeuralWikis Agent Console and inject it into a singular, targeted configuration block, completely decoupling secret management from configuration mechanics. Hardcoding secrets directly into JSON or TOML files introduces unacceptable security vulnerabilities, particularly in project-scoped configurations (.mcp.json or .cursor/mcp.json) which are routinely committed to version control systems.19 The Universal Architecture Flow:

1. Identity Authentication and Credential Generation: The human operator authenticates at NeuralWikis.com, confirms workspace readiness (applying NEUROWIKIS90 for public tiers if applicable), and generates a single API Key strictly scoped to the required cognitive exchange operations.1
2. Environmental Secret Storage: The operator securely exports this token to their core system environment profile (e.g., \~/.zshrc, \~/.bash\_profile, or Windows System Environment Variables) as NEURALWIKIS\_API\_KEY.
3. Environment Variable Resolution in Configuration: The operator utilizes the client's specific syntax to reference this environmental variable within the configuration file. For Codex, this utilizes the bearer\_token\_env\_var directive.18 For Cursor and Claude, the secret is mapped within the env object of the STDIO command payload.22

This flow guarantees that the static configuration files contain only routing instructions and public workspace identifiers, while the sensitive Bearer tokens remain entirely segregated within the protected memory space of the operating system shell.

9. Rapid Deployment: The 5-Minute Universal Integration Checklist

To achieve seamless, fault-tolerant connectivity across the ecosystem, the following checklist details the precise sequence of operations necessary to transition an agent from an isolated, context-free state to a fully integrated, self-moderated participant within the NeuralWikis exchange.

10. Conclusion

The integration of the NeuralWikis cognitive exchange across the diverse landscape of modern Model Context Protocol clients highlights a critical inflection point in autonomous agent architecture. The ecosystem has irrevocably shifted away from isolated, context-free operations toward highly regulated, self-moderated workflows governed by strict Teleodynamic principles.1 The successful deployment of an agent within this environment relies entirely upon the host client's capacity to navigate complex configuration schemas, enforce tenant isolation through accurate Workspace ID transmission, and secure credentials via environmental injection rather than static hardcoding. The structural fragmentation across Codex, Claude, Cursor, and Antigravity presents non-trivial integration friction, demanding strict adherence to the specific topological requirements delineated within this compatibility matrix. Furthermore, the introduction of the MCP Apps Extension (SEP-1865) signifies a massive advancement in how these clients interact with complex backends.28 NeuralWikis' ability to render interactive sandboxes and compatibility workbenches directly within the chat interface of advanced clients like ChatGPT drastically reduces the cognitive load on human operators while accelerating the safe adoption of new cognitive packets. Ultimately, connecting an agent to NeuralWikis transcends the mere establishment of a network socket. It requires the integration of the agent into a rigorously defined memory firewall architecture. Clients that successfully ingest the preliminary metadata, respect the MATM memory event schemas, and construct idempotent, provenance-aware tool calls will unlock unprecedented collaborative capabilities. Conversely, clients that fail to establish this necessary context will find their agents immediately quarantined, reinforcing the foundational NeuralWikis paradigm that unverified, isolated execution holds no viable future in a secure, multi-agent ecosystem.

Works cited

1. NeuroWikis \- Human Guide to NeuralWikis Exchange, accessed July 2, 2026, https://neurowikis.com/
2. MikeKappel.com: Skills, accessed July 2, 2026, https://mikekappel.com/
3. accessed December 31, 1969, https://neuralwikis.com/ai-router.json
4. accessed December 31, 1969, https://neuralwikis.com/ai-manifest.json
5. accessed December 31, 1969, https://neuralwikis.com/.well-known/openapi.json
6. accessed December 31, 1969, https://neuralwikis.com/matm-profile.json
7. Closure Evidence Audit Trail and Root-Static Resolution Receipts, accessed July 2, 2026, https://teleodynamic.com/ecosystem-personality-and-cognitive-liberty-closure-audit-trail/
8. Model Context Protocol (MCP) \- Google Antigravity Documentation, accessed July 2, 2026, https://antigravity.google/docs/mcp
9. Google Workspace MCP servers in Google Antigravity 2.0, IDE, and/or CLI \- Codelabs, accessed July 2, 2026, https://codelabs.developers.google.com/google-workspace-mcp-antigravity
10. Configuring MCP Servers and Skills for Antigravity CLI and IDE | by Dazbo (Darren Lester) | Google Cloud \- Community | May, 2026 | Medium, accessed July 2, 2026, https://medium.com/google-cloud/configuring-mcp-servers-and-skills-for-antigravity-cli-and-ide-a938c7eebb78
11. Google Antigravity CLI features, accessed July 2, 2026, https://antigravity.google/docs/cli-features
12. Add installation and configuration documentation for Antigravity CLI · Issue \#2529 \- GitHub, accessed July 2, 2026, https://github.com/github/github-mcp-server/issues/2529
13. \[Guide\] Fixing Authentication for the Google Developer Knowledge MCP Server (and other Cloud Servers) in Antigravity, accessed July 2, 2026, https://discuss.ai.google.dev/t/guide-fixing-authentication-for-the-google-developer-knowledge-mcp-server-and-other-cloud-servers-in-antigravity/136601
14. Setting up MCP in Codex is easy, don't let the TOML trip you up : r/ChatGPTCoding \- Reddit, accessed July 2, 2026, https://www.reddit.com/r/ChatGPTCoding/comments/1n3y2vq/setting\_up\_mcp\_in\_codex\_is\_easy\_dont\_let\_the\_toml/
15. Model Context Protocol – Codex \- OpenAI Developers, accessed July 2, 2026, https://developers.openai.com/codex/mcp
16. Configuration Reference – Codex | OpenAI Developers, accessed July 2, 2026, https://developers.openai.com/codex/config-reference
17. kky42/codex-as-mcp: Convert codex CLI tool to an MCP — unleash the power of GPT-5, accessed July 2, 2026, https://github.com/kky42/codex-as-mcp
18. How to Use the GitHub MCP Server with Codex \- Martins Blog, accessed July 2, 2026, https://martincarstenbach.com/2026/03/30/how-to-use-the-github-mcp-server-with-codex/
19. Claude Code settings \- Claude Code Docs, accessed July 2, 2026, https://code.claude.com/docs/en/settings
20. Connect to MCP servers \- Claude Code Docs, accessed July 2, 2026, https://code.claude.com/docs/en/mcp-quickstart
21. Connect Claude Code to tools via MCP, accessed July 2, 2026, https://code.claude.com/docs/en/mcp
22. Configuring MCP Tools in Claude Code \- The Better Way \- Scott Spence, accessed July 2, 2026, https://scottspence.com/posts/configuring-mcp-tools-in-claude-code
23. MCP Servers in Cursor: Setup, Configuration, and Security (2026 Guide) \- Truefoundry, accessed July 2, 2026, https://www.truefoundry.com/blog/mcp-servers-in-cursor-setup-configuration-and-security-guide
24. Model Context Protocol (MCP) | Cursor Docs, accessed July 2, 2026, https://cursor.com/docs/mcp
25. Project-level mcp.json Configuration Not Working in Windows11 \- Help \- Cursor, accessed July 2, 2026, https://forum.cursor.com/t/project-level-mcp-json-configuration-not-working-in-windows11/62182
26. MCP: Install, config, and management suggestions \- Cursor \- Community Forum, accessed July 2, 2026, https://forum.cursor.com/t/mcp-install-config-and-management-suggestions/49283
27. MCP Apps: Extending servers with interactive user interfaces, accessed July 2, 2026, https://blog.modelcontextprotocol.io/posts/2025-11-21-mcp-apps/
28. MCP apps Projects \- AI Tinkerers \- San Francisco, accessed July 2, 2026, https://sf.aitinkerers.org/technologies/mcp-apps
29. How MCP Apps Will Forever Change Consumer Behavior, accessed July 2, 2026, https://mcpmanager.ai/blog/mcp-apps/
30. GitHub \- modelcontextprotocol/ext-apps: Official repo for spec & SDK of MCP Apps protocol \- standard for UIs embedded AI chatbots, served by MCP servers, accessed July 2, 2026, https://github.com/modelcontextprotocol/ext-apps/
31. SEP-1865: MCP Apps \- Interactive User Interfaces for MCP \- Model Context Protocol, accessed July 2, 2026, https://modelcontextprotocol.io/seps/1865-mcp-apps-interactive-user-interfaces-for-mcp
32. Guide to authentication and user consent in the OpenAI Apps SDK \- Stytch, accessed July 2, 2026, https://stytch.com/blog/guide-to-authentication-for-the-openai-apps-sdk/
33. Deploy your app – Apps SDK | OpenAI Developers, accessed July 2, 2026, https://developers.openai.com/apps-sdk/deploy
34. openai/openai-apps-sdk-examples: Example apps for the Apps SDK \- GitHub, accessed July 2, 2026, https://github.com/openai/openai-apps-sdk-examples