Atelier B MCP Server

Official

by CLEARSY

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
Disambiguation4/5
Most tools target distinct resource-action pairs (project, component, proof, file, code generation). Potential confusion exists between infos_project and list_project_structure, and between list_files and list_components, but the descriptions are detailed enough to disambiguate.
Naming Consistency3/5
All tools share the 'atelierb_' prefix, but the verb-noun pattern is inconsistent. 'infos_project' lacks a verb, 'status' is a bare noun, and 'b0check' and 'pogenerate' embed the object before the verb in an unusual way. A more uniform pattern like 'check_b0' or 'generate_po' would be clearer.
Tool Count3/5
18 tools is at the high end (16-25 feels heavy). For a specialized B-method IDE, the count is understandable, but some read-only informational tools (infos_project, list_project_structure, list_files) could potentially be consolidated to reduce interface surface.
Completeness5/5
The tool set provides comprehensive lifecycle coverage: project and component CRUD, typecheck/B0 check, proof obligation generation/proving/status, file read/write, and C code generation for both components and entire projects. There are no major gaps in the B development workflow.
Average 3.7/5 across 18 of 18 tools scored. Lowest: 3.1/5.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 1 community issues answered or closed in the last 6 months
- 8 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 AGPL 3.0.
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose side effects, return values, and any state changes. It only says 'typecheck' without explaining whether it is read-only, what it returns on success/failure, or whether it modifies project files. This is a minimal disclosure that adds no behavioral context beyond the name.
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 a single concise sentence with no wasted words. It front-loads the action and directly states the purpose, making it easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter tool with full schema coverage, the description is adequate but not complete. It lacks behavioral context such as expected output, error behavior, or any relationship to the broader typecheck/proof workflow. This leaves the agent uncertain about what to expect after invocation.
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?
The input schema already provides 100% coverage with clear descriptions for both parameters. The description adds no extra semantics beyond using the phrase 'B component', which is redundant with the schema's 'component to typecheck'. Therefore, it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Typecheck') and resource ('a B component'), with clear intent ('verify syntax and type correctness'). It is distinct in purpose from sibling tools like b0check or prove, but it does not explicitly differentiate itself or mention scope beyond a single component, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives, no prerequisites (e.g., project must exist), and no exclusions. There is no mention of whether to use before b0check or prove, leaving usage entirely implied.
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?
The verb 'Get' implies a read-only operation, which is a behavioral trait, but no other behavior is disclosed (e.g., return format, error handling). Without annotations, the description carries the burden but provides minimal context.
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 a single, focused sentence of 8 words. It is front-loaded and contains no unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and the description says only 'detailed information' without specifying what fields are included. Given the existence of overlapping sibling tools, this vagueness could lead to incorrect selection.
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?
The schema already documents 'project_name' with a description, and the tool description adds no additional parameter semantics. With 100% schema coverage, the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get') and resource ('detailed information about an Atelier B project'). However, 'detailed information' is vague and does not distinguish from sibling tools like atelierb_status or atelierb_list_project_structure.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. The description only states what it does, not the context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the function. It does not mention return format, potential side effects, or that the operation is read-only. While the verb 'get' implies a read, no additional 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that immediately communicates the tool's purpose. It contains no filler, front-loads the action, and is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and complete schema, the description is minimally adequate. However, without an output schema, it does not explain what 'proof status' means or how the result is presented. This leaves some ambiguity for the agent about the expected return value.
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?
The schema already describes both parameters with 100% coverage. The tool description adds no new semantic detail beyond what is in the schema; it merely paraphrases the component_name description. Since the baseline is 3 for full schema coverage, this is appropriate.
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 ('Get') and the resource ('proof status') with a scope indication ('component or entire project'). This distinguishes it from sibling tools like atelierb_prove (which performs proofs) or atelierb_typecheck (which runs type checks). The purpose is unambiguous 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 Guidelines2/5
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 prerequisites, exclusions, or why one would choose this over a sibling tool. The context is implied by the name but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing side effects. It only says 'Generate proof obligations' without indicating whether this writes files, overwrites existing POs, requires prior steps, or is destructive. This is a significant transparency gap for a generation tool.
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 a single sentence, front-loaded with the action verb, and contains no fluff. It is appropriately sized for the straightforward purpose it conveys.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too sparse for a tool with no annotations and no output schema. It omits important context such as side effects, file output, prerequisites, and how the 'differential' flag fits into the workflow. The agent is left without enough information to understand the tool's full impact.
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?
The input schema provides descriptions for all three parameters (100% coverage), so the description does not need to add parameter-level detail. It adds no extra meaning beyond the schema, receiving the baseline score of 3.
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 ('Generate'), the resource ('proof obligations'), and the scope ('for a B component'). It distinguishes from sibling tools like atelierb_prove (which proves the POs) and atelierb_typecheck (which type-checks), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when one wants to generate proof obligations, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites (e.g., a type-checked component) or exclusions. The context is clear but no direct guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry full behavioral disclosure. It explains force levels but does not mention prerequisites, side effects, whether the operation modifies project state, or how results are returned. This leaves important behavioral aspects opaque for a tool that runs a prover.
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 efficient, using a single sentence to state the action and a short clause to list force levels. There is no fluff or redundant wording, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description needs to provide more contextual details. It omits critical behavioral information such as whether the proof process is read-only, what happens on success/failure, and any preconditions like typechecked components. This is insufficient for a complex proving 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?
The input schema already provides 100% coverage of parameters, including descriptions for force, project_name, and component_name. The tool description restates the force level semantics but adds no additional meaning beyond what the schema already documents.
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 states a clear action 'Run automatic prover' on a specific resource 'B component', and the force levels add concrete operational detail. This distinguishes it from sibling tools like typecheck and b0check, making the purpose unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for proving a B component but does not explicitly explain when to choose this tool over alternatives such as atelierb_typecheck or atelierb_b0check. No exclusions or context are provided beyond the core action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation via 'Get', but does not mention whether the structure is recursive, includes hidden files, or how errors (e.g., invalid project name) are handled. This is a notable transparency gap.
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 a single sentence, front-loaded with the action 'Get', and contains no filler. It earns its place by clearly communicating the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter and no output schema. The description provides a minimal but sufficient overview, yet lacks details on output format and recursion behavior. Given the absence of annotations, a bit more context would improve completeness, but the core is conveyed.
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?
The input schema fully documents project_name with a basic description. The tool description does not add further semantic detail beyond the schema, but with 100% schema coverage, the baseline score of 3 is appropriate.
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 retrieves the directory structure of a B project, listing files and subdirectories. It distinguishes itself from sibling tools like list_projects (which lists projects) and list_files (which likely lists files), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The purpose implies usage for inspecting project structure, but no comparative guidance is provided.
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 the full burden. It states the action (list) and scope (workspace), plus filtering options, which gives some behavioral context. However, it does not disclose the return format, whether the search is recursive, or any limitations such as requiring a project to be open.
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 exactly two sentences, front-loaded with the main purpose and immediately followed by filtering capabilities. No unnecessary words or repetition.
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?
For a simple read-only listing tool with only two optional parameters, the description is nearly sufficient. It covers the core functionality and filters. It could be improved by explicitly stating the output (e.g., list of file paths) and differentiating from list_components, but overall it provides adequate context.
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?
The input schema already provides full descriptions for both optional parameters, giving 100% coverage. The description's mention of 'filtering by project and extension' adds little beyond the schema, and the example extensions (.mch, .ref) are also present in the schema's extension_filter description.
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 function: 'List B source files in the workspace.' It specifies the resource (B source files), the action (list), and the scope (workspace). The mention of filtering by project and extension also distinguishes it from sibling listing tools like list_projects and list_components.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives. It does not reference sibling tools or state exclusions. While the purpose implies usage for listing source files, the description lacks any 'use this when' or 'not for' context.
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 must disclose side effects. It does state 'Creates the file in src/ with a template and registers it with Atelier B', covering key behavioral traits. However, it omits error handling, whether it overwrites existing components, and whether the project must exist, leaving gaps in 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 two sentences, front-loaded with the primary action, and every word contributes meaning. It is appropriately concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema and no annotations, the description covers the core behavior (file creation and registration) but lacks details about return values, error scenarios, and prerequisites such as an existing project. It is adequate but not fully complete for the complexity of the 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?
Schema description coverage is 100%, so the baseline is 3. The description adds marginal value by mentioning template generation fallback when content is absent, but does not elaborate on the parameters beyond what the schema already documents.
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 begins with 'Add a new B component (machine, refinement, or implementation) to a project', which clearly states the specific verb, resource, and scope. It distinguishes itself from sibling tools like atelierb_create_project (project-level) and atelierb_write_file (generic file writing) by specifying component creation and registration with Atelier B.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by describing the action and registration purpose, but it does not explicitly state when to use this tool instead of alternatives like write_file or create_project. No exclusions, conditions, or prerequisite mentions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that output goes to the lang/c directory, but does not state whether existing files are overwritten, what preconditions apply (e.g., component existence), or other side effects of generating files.
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 two sentences long, front-loaded with the primary action and output location, and contains no filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description and schema together explain the core purpose, parameters, and output directory, making basic usage understandable. However, it lacks guidance on preconditions, error behavior, and how this relates to project-level generation, leaving meaningful gaps for an agent.
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?
The schema fully describes all three parameters, including the profile enum, so the baseline is 3. The description adds context that component_name refers to an implementation or basic machine but provides no additional syntactic or formatting detail 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 opens with the specific action 'Generate C code' for a 'single B component' and names the output directory. It clearly distinguishes this single-component generation tool from the sibling generate_project_c.
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?
It provides clear context: use for a single component (implementation or basic machine) and not for a whole project. However, it does not explicitly mention the project-level alternative or state when not to use this tool, so it falls short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits itself. It indicates a validation action ('verify') which implies a read-only check, but it does not specify whether the check modifies any state, what happens on pass/fail, or any side effects. The 'required before C code generation' context is workflow guidance rather than a disclosure of runtime behavior, leaving the agent with incomplete information about side effects or outcomes.
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 a single, well-structured sentence that is front-loaded with the action ('B0 check') and includes essential context (purpose and prerequisite). There is no redundant or extraneous information, making it highly efficient for an agent to process.
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?
This is a simple tool with two required parameters and no output schema. The description captures the core purpose and a key prerequisite (required before C code generation), which is enough for an agent to understand when to invoke it. However, it does not describe the return value or error behavior, which would be helpful in the absence of an output schema. Still, given the tool's simplicity, the description is largely sufficient.
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?
Schema coverage is 100%, so the schema already fully documents both parameters (project_name and component_name). The description adds the domain context that the component is 'a B component' and that the check is about B0 compliance, but it does not provide additional parameter-level detail beyond what the schema gives. This meets the baseline for full 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 uses a specific verb phrase 'B0 check' with a clear resource ('a B component') and purpose ('verify it is B0 compliant'). It further contextualizes via 'required before C code generation', which distinguishes it from sibling tools like typecheck, prove, and generate_c. This leaves no ambiguity about the tool's core function.
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 states a clear precondition: the B0 check is required before C code generation. This gives a clear 'when to use' signal. However, it does not explicitly mention when NOT to use it or name alternative tools (e.g., typecheck, prove), so it falls short of a full 5.
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?
The description discloses the critical destructive behavior: setting delete_files=true permanently deletes all project files. With no annotations, this warning is essential and effectively signals irreversible consequences. However, it does not explicitly state the non-destructive behavior when delete_files=false.
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?
Two short sentences with immediate purpose and a clear warning. Every word earns its place, with no redundancy or filler.
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?
For a simple deletion tool with full schema coverage and no output schema, the description plus warning covers the key behavior adequately. A minor gap is the lack of explicit mention that delete_files=false only unregisters, but the schema compensates. Overall, sufficiently complete.
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?
Schema description coverage is 100%, so both parameters are well-documented. The description's warning about delete_files adds emphasis but no new semantic information beyond the schema's existing description. Baseline score of 3 is appropriate.
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 the action ('Remove') and resource ('Atelier B project'), and the warning about delete_files provides additional specificity. It is distinct from sibling tools like atelierb_remove_component, which targets a different resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives (e.g., remove_component). The warning is informative but does not provide context for tool selection, prerequisites, or exclusions.
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 the burden. It discloses the output directory (lang/c) and that it generates code, which is a write operation. However, it does not mention whether existing files are overwritten, whether a project must already exist, or any other side effects. This is adequate but not rich.
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?
Two sentences, no filler, front-loaded with the core action. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description covers purpose and output destination but lacks prerequisite details (e.g., must have an existing project created via atelierb_create_project) and side-effect details. It is minimally adequate for use.
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?
Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no additional parameter semantics. Baseline 3 is appropriate.
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 a specific action: 'Generate C code for a complete B project from a toplevel component.' It names the resource (project, toplevel component) and distinguishes from sibling atelierb_generate_c, which likely targets individual components.
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 gives clear context: it is for a complete project from a toplevel component, and output goes to lang/c directory. It does not explicitly name alternates or exclusions, but the scope is well defined relative to siblings.
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 provided, the description carries the full burden. It discloses the key behavioral variation: the tool can 'unregister' the component by default or delete the source file if the optional flag is set. This is valuable context beyond the raw schema. However, it does not mention potential side effects (e.g., reversibility, dependencies, permissions) or error conditions. The description is adequate but not rich in behavioral detail.
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 two short sentences, front-loaded with the primary action and followed by the conditional behavior. Every word earns its place; there is no redundancy or filler. It is appropriately sized for the tool's simplicity.
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 only three parameters (all documented in the schema) and no output schema, the description adequately covers the core behavior and the optional file deletion. It is complete enough for an agent to understand the tool's purpose and main options without additional details. The tool's low complexity means no further context is necessary.
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?
The schema description coverage is 100%, with all three parameters (project_name, component_name, delete_file) having clear descriptions. The tool description adds no extra meaning beyond the schema—it only restates the delete_file behavior in prose. The baseline of 3 applies because the schema already does the heavy lifting, and the description provides no additional parameter-level insight.
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: 'Remove a component from an Atelier B project.' It also specifies the optional behavior of deleting the source file. This distinguishes it from sibling tools like atelierb_remove_project (which removes entire projects) and atelierb_add_component (which adds components). The verb-resource pairing is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: when you want to remove a component, optionally with file deletion. However, it does not explicitly mention when not to use this tool (e.g., when you want to remove an entire project) or name alternatives. No clear exclusions are provided, making this a minimum-viable level of guidance.
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 the burden of disclosing behavior. It adds that the tool creates subdirectories ('bdp, lang, and src'), which is useful context. However, it does not mention what happens if the project already exists, whether permissions are required, or what the success/error response looks like. It provides some behavioral insight but lacks depth.
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 a single, front-loaded sentence that efficiently communicates the action, resource, and outcome. It contains no filler or redundant information, earning a perfect score.
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?
For a simple creation tool with two well-documented parameters and no output schema, the description provides the core purpose and resulting structure. It is complete enough for an agent to select and invoke the tool correctly, though it could mention project_type options, but those are already in the schema.
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?
The input schema has 100% coverage, with descriptions for both project_name and project_type. The tool description does not add any parameter-specific details beyond the schema, so the baseline of 3 is appropriate. The directory structure mention is about the project outcome, not the parameters.
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: 'Create a new Atelier B project' with a specific resource (project) and scope (in the workspace). It also details the directory structure ('with bdp, lang, and src subdirectories'), distinguishing it from sibling tools like atelierb_remove_project or atelierb_add_component.
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 implies usage for creating a new project, and the context is clear given the tool's name and siblings. However, it does not explicitly state when not to use it (e.g., if a project already exists) or mention alternatives like listing existing projects. This is a minor gap, but the intended use case is unambiguous.
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 provided, the description carries the full burden of behavioral disclosure. The word 'List' implies a read-only operation and the parenthetical clarifies the scope, but it does not mention return format, potential errors, or whether the operation has any side effects, which would provide fuller 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 a single concise sentence followed by a useful parenthetical clarification. There is no redundant or filler content.
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 parameter, no output schema), the description is mostly sufficient, telling the agent that it lists all components in a project and defining component types. It omits return-structure details, but this is a minor gap for such a straightforward list operation.
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?
The input schema already fully documents the single required parameter, project_name, with 100% coverage. The description adds no additional meaning beyond what the schema provides, so the baseline score of 3 applies.
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 function with a specific verb ('List') and a specific resource ('components'), and the parenthetical clarifies what counts as a component (machines, refinements, implementations). This distinguishes it from sibling tools like list_projects and list_files.
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 implies the tool is for enumerating components within a project, which is clear usage context. It does not explicitly name alternatives or state when not to use it, so it falls short of the top score.
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 the full burden. The verb 'List' suggests a read-only operation, but no additional behavioral context (e.g., safety, side effects, errors) is disclosed. This is adequate for a simple list but not particularly rich.
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 a single, front-loaded sentence with no wasted words. It states exactly what the tool does and nothing more.
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 its simplicity (no params, no output schema), the description is complete enough for an agent to invoke the tool correctly. It does not detail the return format, but for a list of projects, the expected output is intuitive. Minor gap: could mention that it returns project identifiers.
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 the baseline is 4. The description adds no parameter details, but none are needed. The schema is empty and fully covers the input surface.
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 'List all available Atelier B projects' uses a specific verb (List) and resource (Atelier B projects), clearly distinguishing it from sibling tools like list_components and list_files. The scope is immediately obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need the set of available projects, but it does not explicitly mention alternatives or exclusions. For a simple list tool, this implied guidance is acceptable but lacks the explicit differentiation seen in higher-rated tools.
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 the full behavioral disclosure burden. It mentions the default backup behavior, which is valuable, but does not clarify whether it creates new files or only updates existing ones, nor does it mention permissions or validation of file paths. This leaves some ambiguity for a mutation tool.
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 a single, well-structured sentence. It front-loads the core action, lists supported file types, and mentions the backup feature without redundancy or wasted words.
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?
For a simple write tool with three well-documented parameters, the description covers the essential aspects: purpose, file scope, and backup behavior. It lacks explicit mention of return values or error handling, but these are less critical given the tool's simplicity and the absence of an output schema.
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?
The schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds allowed file types (e.g., .mch, .c, .h) which provides some context for the file_path parameter, but it doesn't significantly enrich understanding 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 the tool writes or updates content of specific file types (B source, C code, Makefile) in the workspace. This distinguishes it from sibling tools like atelierb_read_file, making its purpose unambiguous.
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 provides clear context: this is the tool for writing/updating files in the workspace. It doesn't explicitly mention alternatives or exclusions, but the 'write/update' verb and file type list give sufficient guidance for an agent to know when to use it.
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 provided, the description carries the full transparency burden. It goes beyond a generic 'reads a file' by stating 'Content is returned verbatim' and thoroughly explains the .pmi case, including the absence of operation names and the 'po_labels' list. This is strong disclosure for a read operation, though it could have mentioned error behavior or permissions, which are less critical here.
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 compact and front-loaded, with the main purpose in the first clause. Each of the three sentences earns its place: scope of file types, verbatim return guarantee, and a critical edge-case warning. There is no filler or 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?
For a one-parameter read tool with no output schema, the description covers the core behavior, return guarantee, and an important special-case detail. It does not fully specify the return data structure (e.g., JSON wrapper), but for a simple content-retrieval operation, the description is sufficiently complete.
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?
The schema already fully describes file_path as 'Relative path from workspace root to the file' (100% coverage), establishing a baseline of 3. The description adds context about acceptable file extensions, which is helpful for parameter interpretation, but it doesn't fundamentally alter the meaning of the single 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 opens with the specific verb 'Read' and enumerates the resource types (B source files with extensions .mch, .ref, .imp, etc., C code, Makefile), making the tool's function immediately clear. This distinguishes it from siblings like list_files (which lists names) and write_file (which writes), establishing a clear identity.
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?
It provides clear context for when to use the tool: whenever file content is needed from the workspace. The special .pmi instruction (do not infer operation names from position) is practical guidance for that file type. However, it doesn't explicitly contrast with list_files or state when not to use it, so it falls short of a full 'when-not' exclusion.
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

Copy to your README.md:

[![atelierb-mcp MCP server](https://glama.ai/mcp/servers/CLEARSY/atelierb-mcp/badges/card.svg)](https://glama.ai/mcp/servers/CLEARSY/atelierb-mcp)

Score Badge

Copy to your README.md:

[![atelierb-mcp MCP server](https://glama.ai/mcp/servers/CLEARSY/atelierb-mcp/badges/score.svg)](https://glama.ai/mcp/servers/CLEARSY/atelierb-mcp)

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/CLEARSY/atelierb-mcp'

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