toggle-brain MCP Server
Provides access to the Toggle Brain knowledge base, including resources, prompt templates, and executable scripts from the toggle-brain repository.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@toggle-brain MCP Serversummarise the Toggle Brain positioning docs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
toggle-brain MCP Server
A Model Context Protocol server that exposes the Toggle Brain knowledge base, prompt templates, and executable scripts to any MCP-compatible AI assistant — Claude Code, Cursor, Windsurf, and more.
Content lives in the toggle-brain repository and is automatically synced here on every push. You never need a GitHub token, API keys, or manual updates at runtime — just clone, build, and connect.
What it exposes
MCP primitive | Source in toggle-brain | Example |
Resources |
|
|
Prompts |
|
|
Tools | Any |
|
Related MCP server: thebrain-mcp-server
Prerequisites
Node.js 20 LTS or later
That's it. No tokens, no API keys, no external services.
Setup
1. Clone the repo
git clone https://github.com/toggle-workspace/toggle-mcp.git
cd toggle-mcp2. Install dependencies and build
npm install
npm run build3. Verify it works
node dist/index.js
# Loaded: 153 resources, 15 prompts, 1 toolsConnecting to Claude Code
From inside the cloned toggle-mcp directory, run:
claude mcp add toggle-brain node "$(pwd)/dist/index.js"Then run /mcp inside a Claude Code session to confirm it is connected:
/mcp
# toggle-brain — ConnectedConnecting to Cursor
Add to ~/.cursor/mcp.json (or via Cursor Settings → MCP):
{
"mcpServers": {
"toggle-brain": {
"command": "node",
"args": ["/path/to/toggle-mcp/dist/index.js"]
}
}
}Replace /path/to/toggle-mcp with the actual path where you cloned the repo.
Connecting to Windsurf
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"toggle-brain": {
"command": "node",
"args": ["/path/to/toggle-mcp/dist/index.js"]
}
}
}Replace /path/to/toggle-mcp with the actual path where you cloned the repo.
Remote / HTTP mode
Set TRANSPORT=http to run as an SSE server on a fixed port:
TRANSPORT=http PORT=3000 node dist/index.jsPoint any MCP client at http://localhost:3000/sse.
Usage
Once connected, the AI assistant can:
Browse knowledge — ask it to read resources like "summarise the Toggle Brain positioning docs" or reference
kb://brain--services--copywritingdirectlyRun prompt templates — ask it to use a prompt like
generators--email-sequencewith your variables filled inExecute tools — any
.tsor.pyscripts from toggle-brain are callable as tools
In Claude Code, confirm what is loaded at any time:
/mcpFor maintainers
How the sync works
Content in this repo is kept up to date by a two-step GitHub Actions pipeline:
toggle-brain runs
.github/workflows/notify-mcp.ymlon every push tomain. This workflow dispatches arepository_dispatchevent of typetoggle-brain-updatedto thetoggle-mcprepository.toggle-mcp has
.github/workflows/sync-brain.ymlwhich listens for that event, checks out toggle-brain, copies its contents into this repo, and commits and pushes the result.
The MCP server reads from the local content/ directory at runtime — no network calls, no tokens required for end users.
Required secret
The toggle-brain notify workflow needs a GitHub PAT stored as a repository secret named GH_PAT. This token must have:
repo scope (to dispatch events to toggle-mcp)
workflow scope (to trigger Actions workflows)
Add it at: toggle-brain repo → Settings → Secrets and variables → Actions → New repository secret
Adding the notify workflow to toggle-brain
See TOGGLE_BRAIN_SETUP.md for the step-by-step guide. In short, create .github/workflows/notify-mcp.yml in the toggle-brain repository with the content from toggle-brain-notify-workflow.yml in this repo.
Once this is in place, every push to toggle-brain/main will automatically update the content in this repo within seconds.
Troubleshooting
Symptom | Fix |
| Re-run |
Resources show as empty or missing | Run |
Build fails with type errors | Ensure Node.js 20 or later is installed ( |
Sync Action fails in toggle-brain | Check that the |
Sync Action fails in toggle-mcp | Check that |
HTTP mode not reachable | Confirm |
Available Tools
19 toolsclients_audaura_unitar_assets_build_leadformD
!/usr/bin/env python3
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations and a trivial description, the agent cannot infer any behavioral traits (e.g., side effects, authorization needs, or resource impacts). The description provides zero transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Although extremely short, the description is devoid of useful content. A proper description should be front-loaded with the tool's purpose; this one provides no value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, no annotations, and a vague input parameter, the description fails to provide any completeness. The agent cannot determine what the tool accomplishes or what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool description does not add any meaning beyond the input schema. While the schema has 100% coverage for the single parameter, the description is a shebang line and does not clarify parameter usage or semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is a shebang line '#!/usr/bin/env python3' which does not indicate any purpose or action. It fails to state what the tool does, making it completely uninformative for an agent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when or how to use this tool is provided. No alternatives or context are given, leaving the agent without any basis for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
clients_toggle_design_system_charts_generatorD
!/usr/bin/env python3
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No behavioral traits are disclosed. The description does not mention side effects, permissions, or any runtime behavior. Annotations are also absent, so the description fails entirely to provide transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While the description is extremely short, it is not concise because it lacks essential information. It is under-specified and wastes the opportunity to convey purpose or usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is completely inadequate given the tool's complexity (1 parameter, no output schema, no annotations). There is no behavioral info, no return type, and no usage examples. It fails to provide a complete picture.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no meaning beyond what the input schema already provides. The schema describes 'args' as key-value arguments; the description merely has a shebang line. No additional context for parameters is given.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is only a shebang line '#!/usr/bin/env python3', which does not state the tool's purpose. It is essentially missing and misleading, giving no indication of what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The sibling tools list suggests other generators and utilities, but the description lacks any context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
clients_toggle_design_system_icons_generatorD
!/usr/bin/env python3
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as side effects, permissions, or constraints. The shebang line is irrelevant for agent behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short but not concise in a helpful way. It is under-specified and fails to provide essential information, making it inadequate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a single nested parameter, no output schema, and no annotations, the description is completely incomplete. It does not explain what the tool generates or how to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with a description for the 'args' parameter: 'Key-value arguments passed to the script via stdin'. This adds meaning beyond the schema structure, but the tool description itself adds nothing. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is "#!/usr/bin/env python3", which is a shebang line and provides no information about the tool's purpose. It is missing and misleading as it does not state what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus its siblings or alternatives. The description offers no context for usage decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_brain_bot_hooks_path_guardD
!/usr/bin/env python3
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided and the description gives zero behavioral information. The shebang hints at a Python script but no behavioral traits are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely short but not concise in a helpful way; the single line is not a description and fails to inform the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, no annotations, and a minimal description. For a tool that likely executes a script, this is highly incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with one parameter 'args' described as 'Key-value arguments passed to the script via stdin'. The description adds no extra meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is only a shebang line ('#!/usr/bin/env python3'), which does not state what the tool does. It is missing and misleading for an AI agent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The description provides no context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_remotion.configD
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_explainer_brand_geometryD
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_explainer_brand_isoformsD
Generated from assets/illustrations/step-form.svg (canonical — regenerate, never redraw).
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description 'regenerate, never redraw' is cryptic and does not disclose behavioral traits such as side effects, idempotency, or resource consumption. Agent has no insight into what happens when the tool is invoked.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise at one sentence, but the sentence is incomplete and lacking context. Conciseness is negated by insufficient information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a simple schema and no output schema, so the description must provide context about what it generates and how it relates to siblings. It fails to do so, leaving the agent completely uninformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema describes 'args' as key-value arguments passed via stdin, but the description adds no meaning about expected keys, value formats, or purpose. With 100% schema coverage, the description contributes nothing to parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description mentions 'Generated from assets/illustrations/step-form.svg' and 'regenerate, never redraw', but lacks a clear verb indicating the tool's action (e.g., 'Generates', 'Renders', 'Outputs'). It does not differentiate this tool from its many siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool, prerequisites, or alternatives among siblings. The description is entirely opaque about intended usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_explainer_brand_wordmarkpathsC
Generated from assets/logos/toggle-wordmark.svg (canonical — never re-typeset).
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It only notes that the asset is canonical and never re-typeset, which hints at idempotency or authoritativeness but does not reveal whether the tool returns data, performs mutations, or requires authorization. The behavioral profile is inadequately specified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, which is concise, but it lacks front-loading of the tool's purpose. It is not wasteful, but it does not fully earn its place by providing critical introductory information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple parameter structure (one optional object) and lack of output schema or annotations, the description should explain the return value, input expectations, and role among siblings. It completely fails to do so, leaving a large information gap for a tool with many sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds no meaning beyond the schema for the single object parameter with arbitrary string properties. However, the schema itself is generic and unconstrained, so the description could have provided guidance on expected keys but did not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description only states the provenance of the asset ('Generated from assets/logos/toggle-wordmark.svg') and asserts its canonical nature, but does not explicitly state what the tool does. The name suggests it provides wordmark paths, but the description is tautological and fails to clarify the tool's action or output.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus siblings. The description gives no context, prerequisites, or exclusions, making it impossible for an agent to decide if this tool is appropriate for a given task.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_explainer_layoutD
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_explainer_tokensD
Source of truth: clients/toggle/design-system/ TOKENS.md + MOTION.md + BRAND-IDENTITY.md
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations and the description gives no behavioral info: it doesn't state if the tool is read-only, what it returns, or any side effects. The agent has no clue about its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short (one sentence) but wastes space on file paths without explaining what the tool does. It is not front-loaded with actionable information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no output schema, the description should explain input format, examples, and output. It fails to provide any meaningful context for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage of 'args' is 100% but the description adds zero context. It doesn't explain key-value pairs or expected keys, so the agent gets no extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description mentions 'Source of truth' and file paths but lacks a verb indicating what the tool does (e.g., read, transform, explain). The purpose is vague despite the name hinting at token explanation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like brand_geometry or layout. No context or alternatives provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_indexD
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_kit_typesC
Data-driven onboarding video series. One engine (OnboardingVideo.tsx) renders
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It mentions 'renders' but does not disclose side effects, required permissions, input/output behavior, or any constraints. Lacks detail for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is extremely short (two fragments), lacking a complete sentence. While brief, it sacrifices essential context; it is under-specified rather than efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given simple schema and no annotations, description should clarify the tool's purpose and role among siblings. It mentions 'data-driven onboarding video series' but does not explain what 'types' means or how the engine relates. Does not cover return values or usage patterns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single 'args' parameter, and schema already provides description: 'Key-value arguments passed to the script via stdin'. The description adds no additional meaning beyond schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states it is a 'data-driven onboarding video series' and mentions an engine renders, but it is unclear what the tool actually does (e.g., provides types? renders videos?). The name suggests types, but description implies rendering, creating ambiguity. Distinguishes from siblings only by mentioning 'One engine (OnboardingVideo.tsx) renders', but does not clarify its own role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus siblings like 'tools_remotion_src_onboarding_videos_welcome' or 'tools_remotion_src_onboarding_registry'. The description does not specify scenarios, prerequisites, or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_registryD
The client-onboarding series, in viewing order. Root.tsx maps this into one
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It fails to state whether the tool is read-only, destructive, or has side effects. The description only describes content, not behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short at two sentences, but the second sentence is vague and unhelpful. While not overly verbose, it lacks clarity and structure for efficient agent parsing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has a nested parameter and no output schema, the description is severely incomplete. It does not explain return values, behavior with different arguments, or integration with sibling tools, leaving a critical information gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although the schema covers the single 'args' parameter at 100%, the description adds no additional meaning about valid keys, expected values, or how arguments affect output. The agent gains no practical guidance beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'The client-onboarding series, in viewing order,' which is more of a label than an actionable purpose. It lacks a clear verb indicating what the tool does (e.g., 'returns', 'defines', 'registers'). The mention of 'Root.tsx maps this into one' is cryptic and does not clarify the function for an AI agent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus its siblings. There is no mention of prerequisites, context, or alternatives, leaving the agent without decision-making information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_videos_google_adsC
VIDEO 3 — Google Ads manager (MCC) link + GA4 Editor for conversion import.
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description provides no behavioral information beyond the stated action. Annotations are absent, and the description does not disclose side effects, required permissions, or what happens when the tool is invoked.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise, using a single line to convey the tool's purpose. It is front-loaded with the key information, but it could benefit from slightly more structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's potential complexity (video generation with arguments), the description is too minimal. It does not explain how to use the tool effectively, what the video will contain, or any details about the expected arguments.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for its single parameter ('args') with a description of 'Key-value arguments passed to the script via stdin'. The tool description adds no additional meaning beyond the schema, which is adequate for a generic parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as focusing on Google Ads manager (MCC) link and GA4 Editor for conversion import. It distinguishes from sibling tools (e.g., meta_ads, tiktok_ads) by specifying the platform. However, it lacks an explicit verb (e.g., 'creates', 'generates') and uses acronyms (MCC, GA4) that may be unclear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, constraints, or scenarios where this tool is appropriate or not.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_videos_meta_adsD
VIDEO 2 — Meta Ads partner access. Flow (share assets to a partner Business
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are available, so the description must carry the full burden of behavioral disclosure. It does not mention whether the tool is destructive, idempotent, requires authentication, or any side effects. The description is too vague to inform safe usage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short but incomplete, not concise. It is a single truncated phrase that does not form a complete sentence. Important information is missing, making it inefficient for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (likely generating a video asset for Meta Ads) and the absence of an output schema, the description provides virtually no context. It does not explain what the tool produces, any prerequisites, or how it interacts with the system. The description is wholly inadequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for the single 'args' parameter, but the description adds no meaning beyond the schema. It fails to specify what key-value pairs are expected or what the values represent (e.g., video settings, partner ID). A higher score would require additional param guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is fragmented and lacks a clear verb+resource pattern. It mentions 'VIDEO 2 — Meta Ads partner access' and 'Flow (share assets to a partner Business)' but does not explicitly state what the tool does (e.g., 'generates a video' or 'creates an asset'). The purpose is ambiguous compared to more descriptive sibling names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There are several sibling tools for different platforms (Google Ads, TikTok, etc.), but the description offers no criteria for selecting this one.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_videos_permissionsD
VIDEO 6 — the consolidated access checklist + the reassurance quartet. Access
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. However, it gives no information about side effects, permissions, or behavior beyond a cryptic label. The agent cannot assess safety or outcome.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short but not concise due to its obscurity. It wastes words on internal references ('VIDEO 6', 'reassurance quartet') that are meaningless without context, while failing to provide essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of a nested object parameter, lack of output schema, and no annotations, the description is severely insufficient. It does not enable an agent to understand input expectations or output behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (one parameter 'args' with a brief description), but the tool description adds no additional meaning. The cryptic text does not clarify what arguments are expected or how they map to functionality.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'VIDEO 6 — the consolidated access checklist + the reassurance quartet. Access' uses cryptic internal references and does not state a clear verb or resource. It fails to convey what the tool does or how it differs from sibling tools like tools_remotion_src_onboarding_videos_welcome.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_videos_seoD
VIDEO 5 — SEO access: Search Console (Full), GA4 (Viewer), CMS (Administrator —
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as side effects, permissions, or what happens when invoked. The description is too truncated to convey any behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short but incomplete, appearing truncated. It does not effectively communicate the tool's purpose in a concise yet informative manner.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a vague, truncated description, the tool definition is severely incomplete. An AI agent cannot reliably determine what this tool does or how to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter 'args' with no description, and the tool description adds no information about what keys/values are expected. Despite 100% schema coverage, the description provides no semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is incomplete and cryptic ('VIDEO 5 — SEO access: Search Console (Full), GA4 (Viewer), CMS (Administrator —'). It does not clearly state the verb or resource; the purpose is vaguely implied but not specified.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. siblings (e.g., google_ads, meta_ads, permissions). The context signals indicate many sibling tools with similar naming, but the description fails to differentiate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_videos_tiktok_adsD
VIDEO 4 — TikTok Business Center. Roles are Admin / Standard / Analyst; events
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses no side effects, safety, or behavioral traits. The mention of roles and events adds minimal context but fails to inform about destructive potential or required permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short but under-specified. It is a fragment rather than a complete sentence. Conciseness should not sacrifice essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (video generation, nested args, sibling tools, no output schema), the description is extremely insufficient. It fails to explain the tool's purpose, input expectations, or output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter (args) with a generic description ('Key-value arguments'). The tool description does not specify what keys (e.g., roles, events) or values are expected, adding no meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description mentions 'VIDEO 4' and 'TikTok Business Center' with roles and events, but it does not include a verb or state what the tool does explicitly. It hints at a video generation for TikTok onboarding but lacks clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus its siblings (e.g., google_ads, meta_ads). The context signals show similar sibling tools, but the description does not differentiate them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tools_remotion_src_onboarding_videos_welcomeC
VIDEO 1 — the warm intro. No platform steps; sets up why we're about to ask
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Key-value arguments passed to the script via stdin |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description gives no behavioral details (side effects, auth needs, output format). Only says 'warm intro', which is too vague for an agent to understand what the tool does.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise (13 words) but lacks sufficient detail. Front-loads key info but fails to provide parameter or behavioral context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool likely generates a video, but the description omits output type, expected input keys, permissions, and integration with other onboarding tools. Entirely inadequate for an agent to correctly invoke.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage for the single 'args' parameter, but the description adds no meaning. The schema itself is generic (object with additionalProperties). Without examples or expected keys, agents cannot properly populate args.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly identifies this as the first welcome video, distinguishing it from sibling tools like 'google_ads' or 'permissions'. It adds 'No platform steps' to clarify scope, but lacks a strong verb like 'render' or 'generate'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies this is the introductory video before platform-specific onboarding, but does not explicitly state when to use or provide alternatives. No guidance on when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
19 tool updates
v1.0.0- First observed
clients_audaura_unitar_assets_build_leadform - First observed
clients_toggle_design_system_charts_generator - First observed
clients_toggle_design_system_icons_generator - First observed
tools_brain_bot_hooks_path_guard - First observed
tools_remotion_remotion.config - First observed
tools_remotion_src_explainer_brand_geometry - First observed
tools_remotion_src_explainer_brand_isoforms - First observed
tools_remotion_src_explainer_brand_wordmarkpaths - First observed
tools_remotion_src_explainer_layout - First observed
tools_remotion_src_explainer_tokens - First observed
tools_remotion_src_index - First observed
tools_remotion_src_onboarding_kit_types - First observed
tools_remotion_src_onboarding_registry - First observed
tools_remotion_src_onboarding_videos_google_ads - First observed
tools_remotion_src_onboarding_videos_meta_ads - First observed
tools_remotion_src_onboarding_videos_permissions - First observed
tools_remotion_src_onboarding_videos_seo - First observed
tools_remotion_src_onboarding_videos_tiktok_ads - First observed
tools_remotion_src_onboarding_videos_welcome
TDQS
Many tools have overlapping domains (e.g., multiple onboarding videos) and lack clear distinctions in descriptions. The path-like names and sparse descriptions make it impossible for an agent to reliably select the correct tool.
Tool names follow no consistent pattern; they mix file paths, project prefixes, and arbitrary slugs. No verb_noun structure exists, and conventions vary wildly (e.g., clients_ vs tools_).
19 tools is a moderate number, but the set is not scoped to a coherent domain. Many tools appear to be internal files (e.g., config files, video scripts) that do not form a purposeful tool surface.
The domain is entirely unclear, so completeness cannot be assessed meaningfully. The tools appear to be a random dump of files with no obvious operations, missing any semblance of CRUD or lifecycle coverage.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
- UnifAPIOAuthcom.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
- QuallaaOAuthcom.quallaa
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
Your memory, everywhere AI goes. Build knowledge once, access it via MCP anywhere.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that exposes Open WebUI Knowledge Bases as tools and resources, enabling AI assistants to search and access knowledge bases.4MIT
- FlicenseNot gradedqualityDmaintenanceWraps TheBrain knowledge graph as an MCP server, enabling AI assistants to search, create, and manage thoughts, links, and notes via natural language.5-

datacore-mcpofficial
AlicenseAqualityAmaintenanceMCP server exposing Datacore's knowledge base, GTD, and engram memory to any AI assistant.539MIT- AlicenseNot gradedqualityAmaintenanceSelf-hosted MCP server exposing a brain's tool registry (vault search, vault access, and connector tools) to MCP clients like Claude Code, scoped to the box owner.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/toggle-workspace/toggle-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server