open-jobsite

by raoulstongea

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 targets a distinct construction or project-management action: four different calculation types, project creation/reading, evidence recording, and three distinct drafting operations. There is no meaningful overlap between the calculation tools or draft tools because the descriptions clearly differentiate their inputs and outputs.
Naming Consistency5/5
All tool names follow a consistent snake_case verb_noun pattern, such as calculate_concrete_volume, create_project, record_site_evidence, and draft_estimate. This makes the tool set predictable and easy for an agent to navigate.
Tool Count5/5
Ten tools is well within the ideal range and fits the server's scope: calculations, project records, evidence, and draft documents. Each tool has a clear purpose and none feel redundant or excessive.
Completeness4/5
The core workflow is well covered: create and read a project, record evidence, draft logs/estimates/change orders, and perform common material calculations. However, there are no update/delete project operations or direct evidence retrieval/list endpoints, which leaves minor workflow gaps.
Average 3.2/5 across 10 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 30 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. 'Calculate' implies a read-only, side-effect-free operation, and 'whole stock pieces' suggests integer rounding. However, it does not disclose how waste_percent affects the result, what rounding convention is used, or whether units must match.
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?
The description is a single, front-loaded sentence with no filler or redundancy. It is appropriately compact, though the brevity comes at the cost of behavioral and parameter 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?
For a calculation tool with three parameters, no annotations, and 0% schema coverage, the description is too thin. It does not explain the role of waste_percent, the rounding logic, unit consistency, or how to choose between this and the other calculation tools. The presence of an output schema helps but does not make up for the missing usage and parameter context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description adds no parameter-specific meaning. It does not explain required_length_ft, piece_length_ft, or waste_percent, nor how they interact to produce the whole-piece count. The property titles alone are not enough to fully disambiguate semantics.
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 ('Calculate') and a clear resource ('whole stock pieces for a linear requirement'). It distinguishes itself from sibling tools like calculate_sheet_count and calculate_concrete_volume by scoping to linear materials, though it could be more explicit about the actual output being a number of pieces.
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 such as calculate_sheet_count or calculate_concrete_volume. The only clue is the word 'linear,' which implies the intended context but leaves the agent to infer selection criteria.
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 behavioral disclosure burden. It usefully states that evidence is recorded locally and that no upload occurs, but it does not mention idempotency, whether records can be overwritten, prerequisites like existing projects, or any local side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with the most important behavioral fact. The second sentence repeats schema enum info but remains brief, so the overall structure is still efficient.
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?
For a five-parameter tool with no annotations, the description is incomplete. It explains no semantics for three key parameters and gives no usage context, leaving the agent uncertain about what valid content or source_reference values look like.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description needed to compensate for the undocumented parameters. Instead, it merely restates the enum values already present in the schema for evidence_type and publication_status, and it provides no explanation of project_id, source_reference, or content.
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 action ('Record sourced evidence') and a scoping constraint ('locally; this performs no upload'). This clearly differentiates it from the calculation and drafting siblings, though it does not name an alternative explicitly.
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 given about when to use this tool versus alternatives, or when not to use it. The only contextual hint is the local/no-upload behavior, which is a behavioral fact rather than a usage rule.
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 communicates that this saves a draft and involves an approval gate, but it does not disclose whether existing drafts are overwritten, whether the project must already exist, what happens on validation failure, or what side effects are triggered.
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 with no wasted words. It front-loads the core action and adds one clarifying constraint, which is appropriately concise for a tool description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has nine parameters, several with defaults or nullable fields, zero schema description coverage, and no annotations. The one-sentence description is far too thin to guide an agent in selecting and populating this tool correctly, even with an output schema available.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description names no parameters. It says 'structured lines' but does not clarify required identifiers like project_id and evidence_ids, currency defaults, or how the approval gate relates to the line items. With nine parameters, this is not nearly enough compensation.
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 names a specific verb and resource ('Save a draft change order') and distinguishes it from sibling tools like draft_estimate and draft_daily_log by naming the change-order resource. The phrase 'structured lines and an approval gate' adds useful purpose-level detail.
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 when-to-use or when-not-to-use guidance, and no mention of alternatives. An agent cannot tell from the description whether to choose this over draft_estimate or record_site_evidence beyond the resource name itself.
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. It does not mention side effects, determinism, or safety. The disclaimer 'not engineering advice' is a quality caveat, not behavioral disclosure. The tool is a pure calculation but that is not stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise and front-loaded, effectively stating the core function in one sentence. However, it omits necessary details like parameter units and waste_percent, making it too sparse to be fully useful. The caveat adds a slight disclaimer but no operational value.
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?
For a simple volume calculation, the description lacks essential input details (units, waste_percent meaning). An output schema exists, so return values are covered, but input semantics are incomplete. An agent would need to infer parameters from the formula, which is not explicit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 compensate for parameter meaning. It only implies that length, width, and depth relate to volume, but does not explain units, the waste_percent parameter, or its default. No specific parameter semantics are provided.
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 computes cubic yards for a uniform rectangular pour, a specific verb-resource pair that distinguishes it from sibling calculations (sheet count, linear pieces, surface area). The caveat 'not engineering advice' adds a clear scope boundary.
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 versus alternatives. The description only implies it is for uniform rectangular pours, but does not address non-uniform shapes or when to choose other calculations. No alternatives or exclusions are mentioned.
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 provided, the description carries the full burden of behavioral disclosure, but it only says 'Save a draft daily log.' It does not explain whether this is a mutating operation, whether it can overwrite an existing draft, whether it is reversible, or what 'draft' implies for downstream workflows.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundant wording and is appropriately front-loaded. However, it is too terse for a tool with seven parameters and zero annotation support, so brevity comes at the cost of completeness.
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 presence of an output schema reduces the need to describe return values, but the description omits semantics for most required parameters, the meaning of evidence_ids, and the behavioral implications of saving a draft. This is insufficient for safe, correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 compensate. It clarifies that worker entries include identifier, role, and hours, but it does not explain required top-level parameters such as project_id, work_date, summary, evidence_ids, or the optional exclusions and assumptions.
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 ('Save') and a distinct resource ('draft daily log'), clearly separating it from sibling drafting tools like draft_estimate and draft_change_order. It also hints at the content of the log by naming worker entries.
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 guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only states what the tool does, leaving selection entirely to the tool name and context signals.
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 provided, the description carries the full burden of behavioral disclosure. It does not state whether the result is rounded up to whole sheets, how waste_percent is applied, or any edge-case behavior such as zero or negative area. 'Whole sheet count' hints at rounding but does not make it explicit.
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 filler. It conveys the core action and the two key calculation inputs ('sheet dimensions' and 'waste') economically.
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 calculator with an output schema and defaulted parameters, this is minimally viable: an agent can infer the intended inputs and purpose. However, the lack of formula-level detail, rounding behavior, and usage guidance leaves notable gaps for a tool that has no annotations or schema descriptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 compensate for the schema's silence. It mentions 'sheet dimensions and waste,' which maps loosely to sheet_width_ft, sheet_length_ft, and waste_percent, but it does not explain area_sq_ft or clarify how the parameters interact in the calculation.
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 identifies the action ('Calculate') and the output resource ('whole sheet count'), and the phrases 'explicit sheet dimensions and waste' signal the tool's calculation scope. This is distinct from sibling tools like calculate_surface_area or calculate_linear_pieces.
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 given about when to use this tool versus alternatives such as calculate_surface_area or calculate_linear_pieces. The description states what it computes but not the context or exclusions that would help an agent choose it confidently.
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 alone must communicate behavioral context. It only discloses creation and locality; it does not explain side effects, behavior on duplicate project IDs, persistence guarantees, or permissions. The project_id constraint adds minor guidance but is not enough for a mutating 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 two short sentences with no filler, and it front-loads the core action before the naming constraint. Every sentence earns its place, and the structure is easy to scan.
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?
Although the output schema exists, the tool has no annotations and 0% parameter schema coverage, which raises the burden on the description. Missing context includes overwrite/conflict behavior, whether creation can fail, and required inputs beyond a terse project_id hint.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 compensate for all three parameters. It adds one useful constraint for project_id (lowercase, non-sensitive) but leaves name and description entirely unexplained, including their purpose 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?
The description clearly states the verb ('Create') and resource ('a new local project'), and the word 'local' distinguishes it from any remote or cloud project concept. Among siblings like get_project and draft_estimate, its role is immediately apparent.
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 the tool should be used when creating a new project, and contrasts implicitly with get_project for retrievals. However, it never explicitly states when not to use it or mentions alternatives, leaving some inference to the agent.
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 behavioral disclosure burden. It correctly identifies this as a calculation and mentions the waste factor, but it does not clarify whether the result includes waste in the total, how waste_percent is applied, or any rounding/edge-case 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?
The description is a single front-loaded sentence with no filler. It conveys the action, object, unit, and special input requirement efficiently.
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 arithmetic tool with an output schema, the core purpose and units are present. However, waste-factor semantics and guidance about when to choose this over related calculate_* siblings are missing, leaving the definition adequate but not fully self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 compensate for parameter meaning. It adds 'rectangular' and 'square feet' to clarify length_ft and width_ft, and 'waste factor' maps to waste_percent, but it does not explain the percentage semantics or the default behavior. This is only partial compensation.
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 specifies a clear verb ('Calculate'), a concrete resource ('rectangular area'), and a unit ('square feet'). The waste-factor clause further differentiates it from sibling tools like calculate_concrete_volume and calculate_linear_pieces.
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?
Usage is implied: call this when you need rectangular area with a waste factor. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named, so the agent must infer routing from the description and sibling names.
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 present, so the description carries the full burden of behavioral disclosure. It does disclose a key behavioral trait: the operation only saves a draft and never sends, approves, or accepts it, and 'auditable' implies persistence with an audit trail. However, it does not mention permissions, idempotency, or behavior when project_id is invalid, leaving meaningful gaps.
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 concise sentences with no filler. The main action and constraint are front-loaded, and the second sentence efficiently delivers the only non-obvious parameter detail: line item requirements.
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?
An output schema exists, so return values do not need explanation. However, with no annotations and a 9-parameter input, the description only partially covers usage context and parameter semantics; top-level required fields and explicit sibling alternatives are left to the schema and tool name. It is reasonably complete for a straightforward draft-save operation but not thoroughly contextual.
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?
With 0% schema description coverage, the description must compensate; it does so for the line_items object by listing required fields (description, quantity, unit, unit_cost) and noting evidence_ids is optional at that level. It does not explain top-level parameters such as project_id, title, currency, tax_percent, or contingency_percent, although their names are fairly self-explanatory. This is partial compensation, not complete 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 opens with a specific verb ('Save') and resource ('auditable draft estimate'), making the primary action unmistakable. It explicitly delimits scope with 'never send, approve, or accept it', which clearly distinguishes it from any finalization or approval workflow. Given the sibling tools are different resource types (change order, daily log, project), this is sufficient.
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 gives clear context: use this tool to persist a draft estimate that must not proceed to sending, approval, or acceptance. However, it does not explicitly name sibling alternatives or state conditions for choosing this tool over them, such as 'use draft_change_order for change orders'. The usage guidance is mostly implied by the resource name and the negative boundary.
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 burden of behavioral disclosure. 'Read' clearly signals a non-mutating operation, and 'complete' indicates the full record is returned. It does not cover error behavior when the project is missing, but for a simple getter this is a minor 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, short sentence that earns its place. It front-loads the action ('Read'), the object ('complete local project record'), and the scope ('local') without any filler 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 operation with one clearly named parameter and an output schema present, the description provides sufficient context. It does not need to explain return values, and the main omission—explicit usage boundaries—is minor for this tool's complexity.
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 only 'project_id' with no description, and the tool description adds no parameter-specific guidance. The parameter is self-explanatory from its name and the tool's purpose, but the description does not compensate for the 0% schema description 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 states a specific verb ('Read') and resource ('complete local project record'), making the tool's purpose immediately clear. It also distinguishes itself from the sibling tools, which are all calculation, creation, or drafting operations rather than retrieval.
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 clearly implies that the tool is used to retrieve an existing project's full local record, providing enough context for an agent to select it over creation or calculation tools. However, it does not explicitly state when not to use it or mention alternatives by name.
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:

[![open-jobsite MCP server](https://glama.ai/mcp/servers/raoulstongea/open-jobsite/badges/card.svg)](https://glama.ai/mcp/servers/raoulstongea/open-jobsite)

Score Badge

Copy to your README.md:

[![open-jobsite MCP server](https://glama.ai/mcp/servers/raoulstongea/open-jobsite/badges/score.svg)](https://glama.ai/mcp/servers/raoulstongea/open-jobsite)

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/raoulstongea/open-jobsite'

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