camofox-browser MCP server (stage2)

by jfjensen

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool has a distinct purpose: interactions (click, type_into, press_key, select_option), tab management (open, close, read), and content retrieval (fetch_snippet, summarize, extract, fetch_urls, fetch_structure, plus tab variants). No ambiguity between tools.
Naming Consistency5/5
Names follow a predictable verb_noun pattern (e.g., open_tab, close_tab, read_tab, fetch_snippet, summarize_tab). Single-word verbs like click and extract are acceptable as they are common actions. The convention is consistent throughout.
Tool Count5/5
15 tools cover the full scope of browser automation: tab lifecycle, element interaction, multiple reading methods (snippet, summary, extract, structure, links). The count is well-balanced, not excessive or sparse.
Completeness4/5
Covers core browsing operations thoroughly: open/close tabs, interact with elements, read pages in various ways, extract structured data. Missing explicit navigation history or tab listing, but these can be managed externally. Minor gap, overall solid.
Average 4.5/5 across 15 of 15 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description states it closes the tab and returns a short confirmation, but without annotations, it lacks details on potential side effects (e.g., unsaved data loss) or prerequisites (e.g., tab must be opened by open_tab). It 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with two sentences plus a structured Args/Returns section. Every sentence is necessary, and important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one required parameter) and the presence of an output schema (returning a short confirmation), the description covers purpose, usage, parameter, and return value. It is mostly complete, though it could mention handling of tabs not opened by open_tab.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning to the tab_id parameter by noting it is 'the handle returned by open_tab,' which is not present in the schema (which only specifies type string). This helps the agent understand the origin and usage of the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Close a persistent tab', verb+resource) and specifies that it applies to tabs opened with open_tab, distinguishing it from the sibling close_all_tabs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Call this when you have finished interacting with a page, to free the browser tab,' providing clear usage context. It does not explicitly exclude alternative scenarios or mention when not to use it, but the guidance is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that it uses the same chunk-and-merge extractor as `extract` and works on a live tab. However, it does not detail potential side effects, rate limits, or what happens if the tab changes, which would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two well-organized paragraphs: first the main purpose and usage, then parameter and return details. It is front-loaded and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's behavior, parameters, return format, and distinguishes it from siblings. It could mention that the tab must already be open, but that is implied. Given the low complexity and presence of an output schema, it is fairly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains both parameters: tab_id is a handle from open_tab, and schema is a JSON Schema same as for `extract`. This adds meaning beyond the raw schema (which has no descriptions), especially given 0% schema coverage. The explanation is sufficient but could include examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool extracts structured data from the current tab using a JSON Schema, distinguishing it from the sibling `extract` tool which opens a URL. The verb 'extract' and resource 'tab' are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells when to use this tool: 'for named fields on a page you have navigated or interacted your way to', contrasting with `extract`. It provides clear context but lacks explicit 'when-not-to-use' or alternative tools beyond the implicit comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description only reveals it returns JSON with url and ref count. Does not disclose potential side effects like navigation or waiting behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise with clear Args and Returns sections. Every sentence adds value, no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, arguments, return for a simple key press tool. Could mention if key is case-sensitive or list valid keys, but adequate for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Given 0% schema coverage, description adds meaning: explains tab_id as handle from open_tab and key with example 'Enter'. Could list more key names or format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it presses a single key in an open tab with examples like 'Enter', 'Tab', 'Escape'. Distinct from sibling tools like 'click' and 'type_into'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit use cases: submit form, move between fields, dismiss dialog. Lacks explicit 'when not to use' or alternatives, but context from siblings implies type_into for multiple characters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool is destructive ('tears down the session') and mentions that opening a tab afterward starts a fresh session, implying session termination. However, it lacks specifics on whether state is saved or how the confirmation behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, using three clear sentences. The first sentence states the action, the second provides usage context, and the third describes the return value. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, a simple return of a short confirmation, and clear context from sibling tools, the description is fully complete. It explains both the mechanism (closing all tabs) and the reason (automatic shutdown cleanup).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so no parameter description is needed. The baseline for no parameters is 4, and the description does not add or subtract from that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool closes ALL persistent browser tabs at once, tearing down the browsing session. It distinguishes from the sibling 'close_tab' which closes individual tabs, making the purpose unique and specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'You normally do not need this; the agent calls it automatically on shutdown', providing clear guidance on when not to use it. It implies that for individual tab closures, 'close_tab' should be used, though it does not explicitly mention that alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses return format (plain-text outline indented by level) and notes pages with thin outlines. Lacks details on side effects or auth requirements, but overall informative.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise, well-structured description: purpose, usage, then arguments. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, usage, and return format adequately. Could mention if full page is read, but sufficient for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Explains 'url' as 'The full URL to outline' and 'user_id' as optional with same semantics as fetch_snippet. Adds meaning but user_id relies on external reference.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches a webpage and returns its heading outline, like a table of contents. It distinguishes from sibling tools like 'summarize' and 'extract'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use (to see page organization before reading) and when not to (thin outlines, then prefer 'summarize' or 'extract').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that URLs are made absolute and deduplicated, which is key behavioral detail. It does not mention rate limits or auth, but as a read operation these are less critical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: purpose first, then usage guidance, then args, then returns. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple parameters and presence of an output schema, the description is reasonably complete. It explains the return format, but could mention edge cases like empty link lists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fill the gap. It explains 'url' as 'The full URL to read links from' and 'user_id' as optional with reference to another tool. This provides meaningful context beyond the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Fetch a webpage and return the links'), specifies the output format ('list of {text, url} pairs'), and distinguishes its use from siblings like fetch_snippet by focusing on navigation and link discovery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use it: 'when you need to navigate from a page... to find which link to follow next, or to see what a page links out to.' It does not explicitly mention alternatives or when not to use, but the context is clear enough for the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It explains the tool reads the entire page without truncation, uses a chunk-and-combine summarizer, and returns plain text. It does not mention rate limits or prerequisites like tab loading, but is otherwise transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the main purpose, and logically structured with usage context, arguments, and return value. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low parameter count and presence of an output schema, the description adequately covers purpose, usage, and return format. It could mention edge cases (e.g., tab not fully loaded) but is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description compensates by explaining `tab_id` as 'the handle from open_tab' and `question` as an optional focus. This adds significant meaning beyond the raw schema, though it could detail valid values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool summarizes the current page in an open tab, and explicitly distinguishes it from sibling `summarize` (URL-based) and `read_tab` (head-only). It uses specific verb+resource and differentiates from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description advises using this tool after navigation/interaction for a full summary, notes that `read_tab` truncates, and references sibling `summarize`. It provides clear when-to-use context but does not explicitly list all exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description explains the mechanism (fetches page, uses local LLM to populate schema) and return format. Missing details on error handling or limitations, but adequately transparent for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well structured with key info front-loaded. Could be slightly more concise but no wasted sentences. Each sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers core functionality, usage, parameters, and return behavior (null for unfound fields). With output schema present, return details are less critical. Missing limitations but overall complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 0% description coverage, but the description fully compensates: explains `url`, gives detailed guidance and example for `schema`, and notes `user_id` semantics. Provides essential meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches a webpage and extracts structured data per a JSON Schema. It distinguishes from siblings like `fetch` by noting the structured extraction use case.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (specific fields, structured content) and when to prefer the sibling `fetch` tool for open-ended questions. Provides clear context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, but the description discloses that the result includes a marker if the page is longer, and explains the user_id parameter's effect on browser context reuse, adding behavioral context beyond schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, well-structured with intro, output explanation, usage guidance, and parameter details, no wasted sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with an output schema, the description adequately explains purpose, output, and parameters, making it complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds meaning: URL must include http:// or https://, and user_id is optional with context reuse behavior explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches a webpage and returns a short snippet from the top, explicitly differentiating it from siblings like 'summarize' and 'extract' for full content or specific fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use it (fast look, confirm URL) and when not to (prefer 'summarize' for full content, 'extract' for named fields), providing clear guidance over alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses the key behavior that refs are renumbered after actions, making earlier reads stale. No annotations provided, so the description carries the full burden; it adequately covers the read-only nature and output variations, though it does not detail error cases or performance.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core purpose, followed by essential guidance in a well-structured Args list. Every sentence is necessary and no fluff. Extremely concise for the information conveyed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple modes, staleness concern), the description covers why to read before actions, what each mode returns, and the source of tab_id. An output schema is available, so the brief return statement suffices.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds significant meaning beyond the bare schema: tab_id is 'The handle returned by open_tab,' and mode explains all three options ('snippet', 'urls', 'structure') with their purposes. Schema coverage is 0%, so the description compensates effectively, though it could note that mode has a default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it reads the current state of an open tab, using specific verbs and resource identification. It distinguishes itself from sibling tools by emphasizing that element refs ([eN]) come from the latest snapshot and are renumbered after actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance to read_tab right before an action because refs become stale, and explains the three modes ('snippet', 'urls', 'structure') with their intended use cases. This differentiates from alternative tools like fetch_snippet or fetch_urls.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses the fetch-and-summarize behavior, chunking for large pages, configurable strategy, and return type. It does not mention error handling or rate limits, but for a read-only tool this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise single paragraph of 6 sentences. Front-loaded with main purpose, followed by details and parameters. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers main behavior (fetch, chunk, summarize, config strategy) and return type. Output schema exists but is not shown; description simply says 'plain-text summary'. Could mention error handling, but sufficient for typical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, meaning the schema has no descriptions. The description compensates by defining each parameter: url (mandatory), question (optional, focusing summary), user_id (optional, same as fetch). This adds crucial semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetch a webpage and return a concise summary of it.' It distinguishes from sibling 'extract' by contrasting free-form summary vs. named fields, and explains the chunking/combining strategy for large pages.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs: 'Use this tool when the user wants a free-form summary of a page, or an answer to an open question about a long page, rather than a fixed set of named fields (use extract for named fields).' This provides clear when-to-use and alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that typing is done into an open tab, uses ref from read_tab, and explains the submit behavior. It does not mention potential side effects or rate limits, but the core behavior is well described.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a clear summary, followed by Args and Returns sections. Each sentence serves a purpose, and the structure is front-loaded with the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main use case and return value (url and ref count). It implies prerequisites like an open tab and existing ref, but doesn't explicitly list error conditions. Given the output schema exists, this is largely adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All four parameters are explained in the Args section: tab_id, ref (with example 'e7'), text, and submit (with behavior details). This adds significant meaning beyond the schema titles, compensating for 0% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Type text into a form field in an open tab, by its ref,' providing a specific verb and resource. This distinguishes it from sibling tools like click and press_key, which have different actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use the submit parameter (true for search boxes/simple forms, false when a button click is needed). It also implies when not to use submit by suggesting clicking the submit button's ref instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses that refs renumber after click, requiring a fresh read_tab. Does not detail other side effects like page navigation, pop-ups, or required permissions, but the note on renumbering is valuable for agent operational correctness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is front-loaded with purpose, followed by usage guidance, then parameter and return details. Every sentence adds unique value. No redundancy or fluff. Well-structured for quick parsing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given low parameter count (2) and existence of output schema, description covers purpose, usage, parameter semantics, and behavioral side effect (ref renumbering). Also describes return as 'JSON with resulting url and fresh ref count'. Complete for a click action with no gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 0% description coverage; description fully compensates. Explains tab_id as 'handle from open_tab' and ref as '[eN] marker (like e42) from tab's latest read_tab snapshot.' Adds concrete examples and context entirely missing from schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states action: 'Click an interactive element... by its ref.' Verb and resource specific. Explicitly distinguishes from siblings by mentioning alternatives like press_key and type_into for form submission.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use: links, buttons, checkboxes, submitting forms with a submit button. Also states when-not-to-use: for forms without a submit button, recommending type_into with submit=True or press_key with Enter. Includes post-click guidance to call read_tab again due to ref renumbering.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It explains that the tool selects by ref and label/value, notes that a dropdown without a ref cannot be selected, and describes the return value. It does not mention any destructive behavior, which is appropriate for a selection tool. Minor omission: no mention of whether the selection triggers navigation or state changes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a clear one-sentence purpose, a usage warning, and an Args section with parameter explanations. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 3-parameter tool with an output schema (indicated), the description covers the key constraints (ref must exist in snapshot) and the return format (url and ref count). It is sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description fully explains each parameter: tab_id (from open_tab), ref (from latest read_tab, must have [eN] ref), value (by visible label or value). This adds essential meaning beyond the schema's property names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Choose an option in a dropdown (a native <select> / combobox)'. It uses a specific verb ('choose') and resource ('option in a dropdown'), and distinguishes from sibling tool 'click' by explicitly stating it is ONLY for <select> dropdowns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use and when-not-to-use guidance: 'This is ONLY for <select> dropdowns. For radio buttons, checkboxes, links and ordinary buttons, use click instead.' This clearly contrasts with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Details behavioral traits: tab persists across calls, need to read_tab to see content, close_tab when finished. Also describes return value (tab_id, settled url, element ref count). No contradictions with missing annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise and well-structured: opens with purpose, follows with usage guidance, then parameter description, then return value. Every sentence adds value; no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Fully addresses the tool's purpose, usage context, parameter constraint, behavioral lifecycle, and return value. Given the simplicity (1 param, output schema exists), the description is complete and leaves no ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds essential constraint beyond the schema ('must include http:// or https://'). With 0% schema coverage, the description fully compensates by explaining the parameter's meaning and requirement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the action ('Open a webpage in a persistent browser tab and return a tab_id handle') and distinguishes from sibling tools by specifying when to use (for interaction) versus when to prefer other tools (plain reading).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides when to use (interact with the page) and when not to (plain reading), listing specific alternative tools (fetch_snippet, summarize, etc.) and the required next steps (read_tab, close_tab).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

local-LLM-agent-mcp-interaction MCP server

Copy to your README.md:

[![local-LLM-agent-mcp-interaction MCP server](https://glama.ai/mcp/servers/jfjensen/local-LLM-agent-mcp-interaction/badges/card.svg)](https://glama.ai/mcp/servers/jfjensen/local-LLM-agent-mcp-interaction)

Score Badge

Copy to your README.md:

[![local-LLM-agent-mcp-interaction MCP server](https://glama.ai/mcp/servers/jfjensen/local-LLM-agent-mcp-interaction/badges/score.svg)](https://glama.ai/mcp/servers/jfjensen/local-LLM-agent-mcp-interaction)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/jfjensen/local-LLM-agent-mcp-interaction'

If you have feedback or need assistance with the MCP directory API, please join our Discord server