The AndroidBuilder MCP Server connects to a Chrome/Chromium session running an App Inventor-family IDE (AndroidBuilder, MIT App Inventor, Kodular, Niotron, AppyBuilder) and lets MCP clients inspect and manipulate the Designer and Blocks workspaces.
Project & Navigation
Get project info: Retrieve the current project name, active screen, view mode (Designer vs. Blocks), IDE type, and page URL.
List screens: Get all available screens in the current project.
Switch screen: Navigate to a different screen in the IDE.
Designer (Read)
Get component tree: Retrieve the full component hierarchy (name, type, uid, children).
Get component properties: Read all visible property values for a specific component.
Designer (Write — requires ANDROIDBUILDER_ALLOW_WRITE=1)
Update component property: Modify a property (e.g., Text, BackgroundColor, Width) of a specific component.
Blocks Workspace (Read)
Get blocks XML: Export the entire Blockly workspace as a pretty-printed XML string for reading or backup.
Blocks Workspace (Write — requires ANDROIDBUILDER_ALLOW_WRITE=1)
Add blocks: Inject Blockly XML blocks into the workspace (with validation before injection).
Clear blocks: Destructively remove all blocks from the workspace (also requires confirm: "CLEAR_BLOCKS").
Unsafe Fallback (requires ANDROIDBUILDER_ALLOW_UNSAFE_CLICK=1)
Click element: Click any arbitrary element on the IDE page via a CSS selector as a last resort (also requires confirm: "CLICK_ELEMENT").
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., "@AndroidBuilder MCP Server List all screens in my project"
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.
Local Model Context Protocol server for MIT App Inventor, AndroidBuilder, Kodular, Niotron, and AppyBuilder. It connects to a Chrome/Chromium session through the Chrome DevTools Protocol and can safely inspect AIA/AIX archives offline.
The server is safe by default: read tools are available immediately, while write tools require explicit environment flags.
Tool | Mode | Notes |
| Read | Project, active screen, view, IDE type, URL |
| Read | Lists available screens |
| Read/navigation | Switches active screen |
| Read | Designer component tree |
| Read | Selects component by name when possible |
| Read | Exports Blockly XML |
| Write | Requires |
| Write | Requires |
| Destructive | Requires |
<<<<<<< Updated upstream | ||
| Unsafe fallback | Requires both write flags and |
======= | ||
| Unsafe fallback | Requires |
Stashed changes |
list_ide_tabs/select_ide_tab| Navigation | Explicit trusted-tab selection | |inspect_aia/validate_aia/diff_aia| Offline read | Safe project archive inspection | |inspect_aix/validate_aix| Offline read | Safe extension metadata inspection | |read_archive_entry| Offline read | Bounded single-entry read | |get_component_catalog/get_component_schema/search_components| Read | Provider-discovered component metadata | |get_block_diagnostics| Read | Counts, warnings, and orphaned value blocks | |take_screenshot| Read | Designer, blocks, or full-page PNG | |update_component_properties| Write | Verified sequential batch update |
All tool results include success. Errors include a stable code; mutation timeouts include outcome: "unknown" and must be verified before retrying.
Related MCP server: Chrome DevTools MCP
Node.js >=22.12
Chrome or Chromium launched with remote debugging enabled
chrome.exe --remote-debugging-port=9222Open your App Inventor-family IDE and load the project in that Chrome session.
npm install
npm run buildRun the server:
node dist/index.jsUse .mcp.json in this repository for local development:
{
"mcpServers": {
"androidbuilder-mcp": {
"command": "node",
"args": ["dist/index.js"],
"env": {
"BROWSER_DEBUG_PORT": "9222",
"ANDROIDBUILDER_ALLOW_WRITE": "0"
}
}
}
}For clients that do not resolve relative paths from the repository root, replace dist/index.js with an absolute path.
Variable | Default | Description |
|
| Chrome remote debugging port |
|
| Max time for page evaluation |
|
| Verbose stderr logging |
|
| Enables property/block mutations |
|
| Enables arbitrary CSS click fallback |
| empty | Dedicated root for relative AIA/AIX paths |
|
| Maximum Blockly XML mutation size |
validated flag through get_project_info. Providers currently share conservative GWT/Blockly fallbacks; AppyBuilder is read-only. A recognized provider is not automatically validated—run live contract tests against a disposable project before advertising production support.The server recognizes IDEs by exact hostname and exposes provider capabilities and a validated flag through get_project_info. MIT App Inventor, AndroidBuilder, Kodular, and Niotron adapters use isolated strategies; AppyBuilder is experimental and read-only. A recognized provider is not automatically considered validated—run the live contract suite against a disposable project before advertising production support.
Stashed changes
Codex plugin manifest: .codex-plugin/plugin.json
Portable MCP config: .mcp.json
Open Agent Skill: skills/androidbuilder-mcp/SKILL.md
See docs/compatibility.md for client-specific setup notes.
The useful transport-independent features from rhyumiranda/appinventor-mcp were adapted to the existing CDP bridge. See docs/appinventor-mcp-comparison.md for the architectural comparison, adopted features, and rejected high-risk RPC mutations.
npm run build
npm test
npm pack --dry-runnpm test builds the server, runs a real MCP SDK smoke test, verifies write tools are gated, checks the no-Chrome error path, and validates package metadata.
Failed to connect to Chrome CDP: start Chrome with --remote-debugging-port=9222.
No active AndroidBuilder/App Inventor tab found: open a project in the debug Chrome session.
Component tree (.gwt-Tree) not found: switch to Designer view.
Blockly is not available: switch to Blocks view.
Write tool rejected: restart the MCP server with ANDROIDBUILDER_ALLOW_WRITE=1.
AndroidBuilder
MIT App Inventor 2
MIT App Inventor Code
Niotron
Kodular
AppyBuilder
MIT
Injects Blockly XML blocks into the Blocks workspace. Validates the XML before injection to prevent silent failures. Requires the IDE to be in Blocks view.
| Name | Required | Description | Default |
|---|---|---|---|
| xmlString | Yes | Blockly XML string (must be valid XML starting with <xml> or <block>) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden. It discloses validation behavior ('Validates the XML before injection to prevent silent failures') and a prerequisite, but omits details like whether blocks are appended or overwritten, and what happens on failure.
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?
Two sentences with no redundancy. The action verb is first, and every sentence adds value: purpose, validation behavior, prerequisites.
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 adequate for a single-parameter tool but lacks details about return values or confirmation, especially since no output schema exists. It covers purpose, validation, and prerequisite.
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 explicit parameter description. The description adds 'Validates the XML before injection', reinforcing the parameter's requirement but not significantly extending 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 clearly states the verb 'injects' and the resource 'Blockly XML blocks into the Blocks workspace', distinguishing it from siblings like get_blocks_xml (retrieve) and clear_blocks (remove). It also adds context about validation and a prerequisite.
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 includes a clear prerequisite ('Requires the IDE to be in Blocks view'), guiding when to use the tool. It does not explicitly list alternatives, but the purpose clarity implicitly differentiates it from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clears ALL blocks from the current Blockly workspace. This action cannot be undone via MCP. Requires Blocks view.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses the scope (all blocks), irreversibility, and precondition (Blocks view). However, it doesn't mention any side effects like undo history or events.
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 with two short sentences. The main action is front-loaded, and every sentence adds value with no wasted words.
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 no parameters and no output schema, the description adequately covers the essential aspects: what it does, irreversibility, and a precondition.
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?
There are no parameters, so schema coverage is 100%. The description adds meaning by specifying 'ALL blocks' and 'current workspace', clarifying the scope of the operation.
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 states it clears ALL blocks from the current Blockly workspace, using a specific verb and resource. It distinguishes itself from sibling tools like add_blocks or get_blocks_xml.
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 context by warning that the action cannot be undone via MCP and requires Blocks view, but does not explicitly mention when not to use it or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clicks an arbitrary element on the IDE page using a CSS selector. Useful as a last-resort fallback for IDE actions not covered by other tools.
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector of the element to click |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must fully disclose behavior. It only states it clicks an element, but does not mention whether it waits, what happens on failure, or if it triggers navigation or destructive actions. Lacks important behavioral details.
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?
Two concise sentences that front-load the core purpose and usage context. No wasted words.
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 tool with one parameter and no output schema, the description covers basic purpose and guidance. However, it lacks information on return value or behavior in edge cases.
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 a clear description of the 'selector' parameter. The description adds no additional meaning beyond the schema, meeting the baseline for high coverage.
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 states the tool clicks an arbitrary element using a CSS selector, and distinguishes itself as a fallback for actions not covered by other tools.
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?
Explicitly says it's a last-resort fallback, implying use only when other tools cannot cover the action. Provides clear context for when to use, though does not enumerate specific exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Exports the entire current Blockly workspace as a pretty-printed XML string. Use this to read existing blocks or back them up. Requires Blocks view.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses export behavior, pretty-printing, and prerequisite. Does not mention side effects (none expected) or return details, but sufficient for a read-only operation.
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?
Two sentences: first explains function, second adds usage and prerequisite. No redundancy, well-structured.
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 parameterless export tool, the description covers what it does, why to use it, and a prerequisite. No output schema needed, but the return value is implied.
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?
No parameters exist; description adds value by explaining the output (XML string) and purpose. Baseline 4 for parameterless tools.
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 states the tool exports the entire Blockly workspace as a pretty-printed XML string, with verb 'Exports', resource 'Blockly workspace', and output format. It distinguishes from siblings like add_blocks and clear_blocks.
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?
Provides usage context: 'Use this to read existing blocks or back them up' and mentions prerequisite 'Requires Blocks view.' Lacks explicit when-not-to-use or alternative names, but adequate for a single-purpose tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Reads all visible property values for a component from the Properties sidebar panel. You must click the component in the Designer first to populate the panel.
| Name | Required | Description | Default |
|---|---|---|---|
| componentName | Yes | Name of the component (e.g. Button1) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that it reads visible properties from a UI panel that requires prior user interaction. No annotations provided, so description carries the burden; it adequately conveys read-only behavior and state dependency.
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?
Two sentences, no redundancy. First sentence states purpose, second adds critical usage condition. Highly efficient and front-loaded.
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 simple tool with one parameter and no output schema, the description covers purpose, prerequisite, and data source. Missing details on return format or error states, but not necessary for effective use given low complexity.
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 a clear description for componentName. Description adds no extra parameter details beyond the schema, which is acceptable; 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 clearly states the tool reads property values for a component from the Properties sidebar. It distinguishes from siblings like update_component_property (write) and get_component_tree (tree structure) by specifying the action and source.
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?
Provides a clear prerequisite: the component must be clicked in the Designer first. This tells the agent when the tool can be invoked. No explicit when-not-to-use or alternatives, but guidance is sufficient for a straightforward tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the full component hierarchy from the Designer view as a tree of {name, type, uid, children}. Requires the IDE to be in Designer view.
| Name | Required | Description | Default |
|---|---|---|---|
| screenName | No | Optional screen name to inspect (defaults to active screen) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description adequately discloses the tool's read-only behavior, the output format, and the required IDE state. However, it does not detail potential errors if not in Designer view or screen not found.
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 two short sentences (25 words) that are front-loaded with the core action and add a critical precondition. No wasted words.
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 tool with one optional parameter and no output schema, the description covers the main behavior and precondition. It lacks details on error handling or differentiation from siblings, but is largely complete.
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 a clear description of the optional screenName parameter. The tool 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 clearly states the tool returns the full component hierarchy from the Designer view, specifies the output structure as a tree of {name, type, uid, children}, and is distinct from siblings like get_component_properties which deals with properties, not hierarchy.
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 a clear precondition (requires Designer view) but does not offer guidance on when to use this tool versus alternatives like get_component_properties or list_screens.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the current project name, active screen, view mode (Designer vs Blocks), IDE type (AndroidBuilder, App Inventor, Niotron, Kodular…), and page URL. Use this first to understand the context before calling other tools.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must cover behavioral traits. It lists the returned fields but does not disclose potential side effects, whether it requires an active connection, or failure modes. As a read-only info tool, side effects are unlikely, but the description could be more explicit.
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?
Two sentences with no wasted words. The first sentence lists the outputs, the second provides usage guidance. It is front-loaded and efficient.
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 simplicity (no parameters, no output schema), the description fully covers what it returns and how to use it. It is complete for its purpose.
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?
There are no parameters, so the baseline is 4. The description adds meaning by explaining what the tool does, which is sufficient since there are no parameters to document 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 clearly states the tool returns project name, active screen, view mode, IDE type, and page URL. The verb 'Returns' is specific, and the scope is well-defined, distinguishing it from sibling tools which are action-oriented or retrieve specific data.
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 explicitly advises using this tool first to understand context before calling other tools. While it does not list when not to use it, the advice is clear and appropriate given its role as a context gatherer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns all screens available in the current project as an array of strings.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It states it returns an array of strings, implying a read operation, but it does not disclose potential side effects, authorization needs, or performance characteristics. The description is adequate but minimal.
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 a single, front-loaded sentence with no unnecessary words. Every word adds value: 'Returns', 'all screens', 'available in the current project', 'array of strings'. It is concise and structured well.
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 simplicity (no params, no output schema, no annotations), the description is minimally complete. It explains the return value but lacks context about assumptions (e.g., requires an open project) or error conditions. Could be expanded slightly for clarity.
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 has no parameters, so the input schema is fully covered. According to calibration, a score of 4 is baseline for 0 parameters. The description adds no parameter info beyond the schema, but that is expected.
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 states the tool returns all screens available in the current project as an array of strings. The verb 'Returns' and resource 'screens' are specific. It distinguishes from siblings like switch_screen and get_project_info by focusing on listing only.
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 implies usage for listing screens but provides no explicit guidance on when to use it versus alternatives like switch_screen or get_project_info. No when-not-to-use conditions are mentioned, which is a gap even for a simple tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Switches the active screen in the IDE. Uses the GWT select element or tab bar to navigate. Call list_screens first to see available screen names.
| Name | Required | Description | Default |
|---|---|---|---|
| screenName | Yes | Name of the screen to switch to (e.g. Screen2) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Mentions use of GWT select element or tab bar, but lacks details on error handling, return values, or side effects.
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?
Two efficient sentences with no wasted words. Front-loaded with purpose, then usage advice.
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 simplicity and single parameter, description covers prerequisite and mechanism adequately. Could mention response behavior but not critical for this tool.
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 covers 100% of parameters, so baseline is 3. Description adds an example value (e.g. Screen2), but no additional meaning beyond 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?
Clearly states it switches the active screen in the IDE, with a specific verb and resource. Differentiates from sibling list_screens by recommending to call it first.
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?
Provides explicit prerequisite to call list_screens first. Could be improved by mentioning when not to use, but the guidance is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Updates a property of a component. Uses 3 strategies in order: (1) GWT BlocklyPanel_setComponentProperty API, (2) top-frame API (iframe-hosted IDEs), (3) DOM input field in the Properties sidebar. Requires Designer view.
| Name | Required | Description | Default |
|---|---|---|---|
| propName | Yes | Property name (e.g. Text, BackgroundColor, Width) | |
| propValue | Yes | New value | |
| screenName | Yes | Screen that owns the component (e.g. Screen1) | |
| componentName | Yes | Target component name (e.g. Button1) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the three strategies and the order, which is valuable. However, it lacks details on error handling, side effects, or what happens if a strategy fails. The mutation nature demands more 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?
The description is extremely concise: two sentences that front-load the action and then provide the strategy details. Every sentence earns its place with no fluff.
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 is a mutation operation with 4 required parameters and no output schema, the description is incomplete. It does not mention return values, error conditions (e.g., invalid component name), or success indicators. The strategies are listed but not explained in enough depth to guide an agent.
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 the baseline is 3. The description adds examples for propName (Text, BackgroundColor, Width) but does not elaborate on constraints or behavior beyond what the schema provides. It offers marginal added 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 clearly states it updates a property of a component, listing three specific strategies, and explicitly mentions the requirement for Designer view. This distinguishes it from sibling tools like get_component_properties, which only retrieves properties.
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 contextual usage guidance by stating the requirement for Designer view and the order of strategies. However, it does not explicitly state when not to use this tool or suggest alternatives for cases like not being in Designer view.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.1.1add_blocksclear_blocksclick_elementget_blocks_xmlget_component_propertiesget_component_treeget_project_infolist_screensswitch_screenupdate_component_propertyEach tool has a clear, distinct purpose: blocks manipulation, component inspection/editing, screen management, project context, and a fallback click. No overlapping or ambiguous tools.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., add_blocks, get_component_tree), making it easy to predict functionality.
10 tools is well-scoped for an IDE automation server, covering blocks, components, screens, and project info without being overwhelming or incomplete.
Covers core read/update operations for blocks, components, and screens, but lacks create/delete for components and screens, and a dedicated view-switching tool, leaving notable gaps that may force reliance on the fallback click_element.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Live browser debugging for AI assistants — DOM, console, network via MCP.
Control real Android and iOS devices with LLM agents — tap, swipe, type, automate flows.
Provides cloud browser automation capabilities using Stagehand and Browserbase, enabling LLMs to i…
Give any MCP-compatible AI assistant a builder for live, hosted web tools and workflows.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/williamcorrea23/androidbuilder-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
