freee-mcp

by newbdez33

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v0.4.7
Disambiguation5/5
Every tool has a clearly distinct purpose. The prepare/commit pairs are well-separated by their read vs write semantics, and the status, list, detail, and review tools each target a specific resource or workflow step. No two tools appear to do the same thing.
Naming Consistency5/5
All tools follow the freee_<domain>_<action> snake_case pattern. The prepare_action/commit_action suffix is used uniformly, and list tools consistently use plural domain names while single-item operations use singular. The naming is highly predictable.
Tool Count2/5
27 tools is above the 25 threshold set in the rubric, making the set feel heavy. While the prepare/commit safety pattern and the multiple subdomains (clock, monthly, personal applications, approvals) justify many of the tools, the overall count is excessive for a single server and may overwhelm an agent.
Completeness4/5
The tool surface covers the main workflows: personal application list/create/cancel/withdraw, monthly attendance status/submit/approve, clock punches, and approval list/detail/action. Minor gaps exist, such as no direct tool for editing an existing application or listing all employees, but these are workaround-able and likely outside the server's intended scope.
Average 4/5 across 24 of 27 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 55 commits in the last 12 weeks
- Last stable release on September 1, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description reinforces read-only with 'without changing freee' and hints at a dependency on a 'selected' summary, but does not disclose nuances like unsupported parameters (group_id/company_id) or UI-state dependence beyond that.
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 communicates the core action and scope without any filler. Every word serves a purpose, making it highly concise and well-structured.
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?
With no output schema and a description that does not explain what the returned data looks like, the agent lacks crucial context. The tool's behavior depends on an unspecified 'selected' summary, and the unsupported backend parameters are only mentioned in the schema, not the description, leaving the overall invocation and interpretation incomplete.
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%, with all three parameters already described, including the notable caveat that group_id and company_id are 'Unsupported by the Playwright backend.' The tool description adds no extra parameter semantics, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Read' and identifies the resource as 'department attendance' or 'monthly attendance-monitor summary', which clearly distinguishes it from sibling tools that focus on individual clock status or approvals. However, the phrase 'selected monthly attendance-monitor summary' is ambiguous about what 'selected' refers to, slightly reducing clarity.
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 like freee_clock_status or freee_approvals_list. It simply states what it reads, without any explicit context, prerequisites, or exclusion criteria, leaving the agent to infer usage from the name and 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?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds context about scope (current account) and default status (pending), but does not disclose additional behaviors such as pagination mechanics or rate limits. This is consistent with the annotations, so no contradiction.
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 main verb, and contains no filler. Every phrase adds value: the action, the scope, and the default behavior.
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 list tool with rich annotations and a clear schema, the description is adequate. It tells what the tool does and its default, while the schema covers pagination and status filtering. It does not explicitly mention pagination or filterable statuses, but these are inferable from the schema, and the absence of an output schema is mitigated by the tool's straightforward list nature.
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 50%: the 'page' parameter is well-described, while 'status' lacks a description. The tool description mentions the default status (pending), which provides minimal parameter context, but it does not explain the meaning of each status value or add details about the page parameter beyond what the schema already states. The description offers limited compensation for the coverage gap.
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 uses a specific verb ('Read') and identifies the resource as 'applications visible in the current account's approval workflow.' This distinguishes it from sibling tools like 'freee_approval_detail' (single item) and 'freee_personal_applications_list' (personal applications), though it does not explicitly name alternatives. It clearly states the tool's purpose without being tautological.
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 listing approval workflow applications and notes the default pending status, but it provides no explicit guidance on when to use this tool versus related list tools (e.g., freee_monthly_approvals_list) or when not to use it. There are no exclusions or alternative tool references.
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?
Annotations already carry the safety profile (readOnly=false, destructive=true, idempotent=false), and the description adds genuine context beyond them: the resulting application 'may still require approval,' follow-up approval is 'authorized only when the policy expressly covers that chain,' and writes must never be blindly retried. These caveats are consistent with the annotations — no contradiction — and materially shape how an agent should treat the result.
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?
Three sentences of roughly 60 words, front-loaded with the core action followed by two distinct behavioral caveats; every sentence earns its place. The prose is dense and occasionally awkward ('when the exact action or an active scoped business policy is user-authorized'), but the structural economy is good.
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 destructive, non-idempotent write with no output schema, the description covers the essential operational context: ordering after prepare, authorization requirements, approval-chain limitations, and retry caution. It does not describe the return value, failure/error behavior, or what happens to the original approved application, which are notable gaps for a tool of this 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?
Schema description coverage is 100%, so all four parameters (id, reason, confirm, fingerprint) are already documented with types, constraints, and meaning, yielding the baseline of 3. The description's authorization phrasing mirrors, rather than extends, the confirm parameter's semantics and adds no per-parameter detail.
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 — 'Create one real cancellation application' — with a clear resource and an ordering constraint, 'after its matching preview,' that distinguishes it from the prepare_cancel sibling and, via the word 'cancellation,' from commit_create/commit_withdraw. The authorization clause is grammatically dense and slightly obscures the core purpose, so it stops 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied by 'after its matching preview' and reinforced by the schema's reference to 'the matching prepare tool,' signaling a prepared-commit sequence. However, no alternative tools are named and no explicit when-not-to-use conditions are given; 'Never retry an unknown write' is a retry rule, not a tool-selection rule.
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?
Annotations already flag destructive/write behavior; the description adds valuable extra context: unknown writes must never be retried, known preview errors may be reprepared under the same policy, and 休暇 approvals revalidate the dependency check and fingerprint before clicking. No statement contradicts the annotations.
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 front-loaded with the core purpose and every sentence carries operational meaning, but the policy/retry/dependency clauses make it dense and longer than necessary. It earns its place for a destructive tool, yet could be tightened.
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 high-stakes commit action with no output schema, the description covers the matching requirement, sequential usage, skip behavior, retry constraints, and a special dependency revalidation case. It misses only minor details like explicit auth/rate limits, which are less critical here.
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 carries parameter documentation. The description references 'fingerprint' and 'preview' but adds little beyond what the schema already states about confirm and fingerprint 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?
States a concrete verb ('Change') and resource ('one real application'), and qualifies that it happens after preview/authorization matching for the exact action or an active scoped policy. It does not explicitly say 'approves or returns' in its main clause, but the policy language and action parameter make the commit behavior clear.
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?
Explains the sequential single-item usage model, says to skip nonmatches or ambiguous items, and gives explicit retry vs. never-retry rules for preview errors and unknown writes. It does not name sibling tools directly, but the prepare/commit pairing and exclusions are strong enough to guide selection.
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?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful context that the backend is exclusive and selected for the MCP server process, but does not elaborate on return format or any additional behavioral traits. This does not contradict annotations, so a mid-range score is appropriate.
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, clear sentence that is front-loaded and contains zero wasted words. It efficiently communicates the tool's purpose.
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 (no parameters), strong annotations covering safety, and the clear one-line purpose, the description is adequate. The absence of an output schema is less critical here because the tool is a read-only status check, and the description provides enough context for basic invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters since there are none, and the schema coverage is 100% (empty 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 verb 'Read' and the resource 'exclusive freee backend selected for this MCP server process'. It distinguishes this from sibling status tools (auth, clock, team) by focusing on the backend itself, which is a unique scope.
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 such as freee_auth_status, freee_clock_status, or freee_team_status. No context is given for selecting this tool or excluding others.
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 annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds relevant behavioral context: no application is changed, ambiguous mappings produce no fingerprint, and confirmation is bypassed only for exact instructions/policies. This is consistent with the annotations and adds value beyond them, though it does not discuss auth or rate-limit considerations.
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?
Three dense sentences front-load the core operation and each sentence contributes information: what is reviewed, when matching applies, and what happens when mapping is ambiguous. The first sentence's long enumeration is heavy, but it communicates the content of the fingerprint without being redundant.
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 there is no output schema, the description leaves the return contract implicit: it says the tool 'bind[s] ... into a fingerprint' and that ambiguity 'produces no fingerprint', but it never explicitly states that the tool returns this fingerprint or that it should be passed to freee_monthly_approval_commit_action. The overall prepare/commit pattern is inferable from sibling names, but not spelled out.
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 parameters are already well documented. The description adds only indirect context ('one exact application' for id, 'requested approval/return action' for action), which does not materially expand on the schema descriptions.
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 identifies a specific verb ('Review') and resource ('one exact 月次勤怠締め application') and states the output concept ('bind ... into a fingerprint'). It establishes a preview-like, non-mutating behavior, but it does not explicitly name sibling tools such as freee_monthly_approval_commit_action or freee_monthly_approval_review to clarify the boundary, relying on the fingerprint jargon for differentiation.
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 gives a clear condition for use: 'For an exact instruction or active scoped business policy', and describes the behavior in ambiguous cases ('Ambiguous mapping produces no fingerprint'). It does not explicitly state when to prefer this over commit_action or review, so alternatives are not called out.
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?
Annotations already supply the read-only, idempotent, non-destructive profile. The description adds genuine behavioral context: the payment-month-to-work-month mapping and the early stop when mapping is ambiguous. That is useful beyond annotations, though it leaves unclear whether stopping means an error or an empty result.
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 focused sentences with no filler. The opening sentence immediately establishes the operation and resource, and the second sentence compactly explains the mapping caveat that governs behavior.
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 single-parameter read-only review tool, the description covers the essential workflow: what is read, what is verified, and when it stops. It doesn't describe the output shape, but with no output schema and a simple review-oriented tool, this is a minor gap rather than a blocking one.
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 single id parameter has 100% schema coverage with a clear description ('numeric No. shown in the freee application list'). The tool description adds no parameter detail, but the schema already carries the semantics, so 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 names a concrete verb and resource: it reads one exact monthly attendance closure application and enumerates what gets verified (summary, daily attendance, alerts, automatic checks). This clearly distinguishes it from list/status/action siblings even without naming alternatives.
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 gives no explicit when-to-use guidance. It never tells the agent to invoke this before an approval action, nor does it contrast with freee_approval_detail or the monthly prepare/commit tools. The mapping-stop clause is a behavioral condition, not a usage rule.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context beyond these: it returns a 'binding fingerprint' and explicitly states that no punch is created. This helps the agent understand the tool's role and side effects without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that covers the core behavior, return value, and side-effect absence without any redundant wording. Every word earns its place; it is concise yet informative.
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 preview tool with strong annotations and a simple parameter set, the description adequately covers the purpose (read and preview), output (binding fingerprint), and the fact that it is non-mutating. It does not explain the fingerprint's downstream use or the Playwright backend limitation for company_id, but these are partly covered by annotations and the schema. Given no output schema, the description gives enough context to use the tool correctly.
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?
The tool description does not elaborate on parameters; it simply says 'a punch action' without explaining the action enum or the company_id field. Schema description coverage is 50% — the required 'action' parameter has no description in the schema, and while its enum is self-documenting, its exact semantics are not explained. The company_id parameter's 'unsupported by Playwright backend' note appears only in the schema, not in the description, so the description provides no added meaning.
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 specifies the tool's function with a specific verb and resource: 'Read and preview one currently available punch action, returning a binding fingerprint.' This distinguishes it from sibling tools like freee_clock_commit_action (which would actually create the punch) and freee_clock_status (which likely reports current state). The title 'Preview a freee clock action' reinforces the purpose.
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 a safe, no-op preview by stating 'No punch is created,' which hints that this tool is for dry-run validation before committing. However, it does not explicitly mention alternatives or contrast with freee_clock_commit_action or freee_clock_status. Usage guidance is present but implicit, not directly stated.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context by scoping to the current employee and listing statuses, but does not disclose additional behaviors like pagination or response format beyond what schema already covers.
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 that front-loads the action and resource, with no unnecessary 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?
Given the simple list operation, strong annotations (readOnly, idempotent), and a schema that documents the page parameter, the description is mostly sufficient. However, the ambiguous 'complete' versus 'all' and lack of return-value details keep it from being fully complete.
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 50%. The page parameter is well-documented in the schema, but the status parameter only has an enum. The description re-states statuses but uses 'complete' instead of the enum value 'all', introducing ambiguity and potentially misleading an agent. It adds no meaningful parameter semantics 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 verb 'Read' and the specific resource 'current employee's personal application list' with statuses. It distinguishes from sibling tools like freee_personal_application_detail by specifying it is a list operation.
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 reads the current employee's personal application list, scoped to specific statuses. However, it does not explicitly mention alternatives or when-not-to-use compared to sibling list tools like freee_approvals_list.
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?
Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds domain-specific context by stating 'never creates a punch' and 'current available,' reinforcing the read-only nature and indicating the tool reflects a stateful snapshot. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action, and contains no filler. Every word contributes to the tool's purpose and safety profile.
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 tool with high schema coverage and strong annotations, the description adequately conveys the purpose. It does not elaborate on the effect of the date parameter or the format of the returned punch actions, but this is not critical given the schema covers parameter basics and the tool's purpose is straightforward.
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%, with both parameters documented in the input schema. The tool description adds no additional parameter semantics, so 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 uses a specific verb ('Read') and clearly identifies the resource ('current available freee punch actions'). It also explicitly states 'This tool never creates a punch,' which distinguishes it from write-oriented sibling tools like freee_clock_prepare_action and freee_clock_commit_action.
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 is for checking available actions before performing a punch, but it does not explicitly state when to use this tool versus the prepare/commit siblings. 'This tool never creates a punch' provides a negative guideline, but no direct alternative or precondition is mentioned.
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?
Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is clear. The description adds the 'authenticated' requirement and 'API backend' availability, which are not in the annotations. However, it does not disclose return format, pagination, or error behavior. Given the strong annotation coverage, the added context 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?
The description is two short sentences with no redundant language. It front-loads the action ('Read') and immediately specifies the resource. Every word serves a purpose, and it conveys the essential information efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (no parameters, no output schema) and the strong annotations, the description is nearly complete. It states the input (none), the operation (read), and the resource (identities). It could optionally detail what 'identities' includes, but the tool name and sibling context make it sufficiently clear for an agent to select and invoke correctly.
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 schema fully covers the input space. With no parameters, the description correctly omits parameter details, and no additional semantics are needed. The baseline for 0 parameters is 4, and the description does not introduce any confusion.
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 verb 'Read' and a specific resource: 'the authenticated freee user and company identities'. This distinguishes it from sibling tools like freee_clock_status or freee_approval_list, which focus on different domains. The phrase 'Available on the API backend' adds deployment context without obscuring the primary purpose.
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 context through 'authenticated' and 'API backend', suggesting it is for retrieving current user/company info on the backend. However, it does not explicitly mention when not to use this tool or name alternatives like freee_auth_status, which might also relate to identity. The guidance is implied but not fully explicit.
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?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the description doesn't need to repeat safety. It adds meaningful behavior: results expose explicit paymentPeriod and mapped work period, and ambiguous mapping fails closed. This goes beyond annotations and clarifies error-prone edge cases, earning a strong score.
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 with no filler. The core purpose is front-loaded in the first sentence, and the second sentence adds precisely one valuable nuance about mapping behavior. Every word earns its place; structure is optimal.
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 read-only list tool with 2 params and no output schema, the description covers core intent, a behavioral edge case (fail closed), and output expectations (paymentPeriod, work period). Pagination is handled in the schema's page description. It doesn't cover error messages or status interaction, but given annotations and simplicity, it's sufficiently complete for an agent to use correctly.
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 50%: the page parameter is well described in the schema, while status is only defined by enum values with no extra text. The tool description adds minimal parameter context—only 'one explicit approval-list page' restates the page intent. It does not explain how status filters results or how the mapping interacts with parameters. Baseline 3 is appropriate given the partial schema coverage and small extra value.
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 clear verb-resource pair: 'Read only 月次勤怠締め applications' (list monthly attendance approvals). It scopes to 'one explicit approval-list page' and adds a distinguishing detail about exposing paymentPeriod and mapped work period, which separates it from the general freee_approvals_list sibling. This is specific and actionable.
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 monthly attendance approvals on a specific page but never explicitly names alternatives (e.g., freee_approvals_list for general approvals) or states when NOT to use this tool. The 'fail closed' clause hints at a boundary condition, but it's not framed as a usage guideline. No exclusion or alternative routing is provided.
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 adds meaningful behavioral context beyond annotations: user-authorization requirements, sequential processing without per-item confirmation, the exact behavior of work_time_action=delete, and a strong 'never retry an unknown write' safety rule. It does not contradict the annotations, though it omits full side-effect or response details.
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 three dense sentences with no filler. Each sentence contributes a distinct actionable constraint: authorization and preview requirement, sequential processing, and the delete-specific behavior plus retry prohibition.
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 a complex 13-parameter write tool with no output schema, the description covers the essential workflow: matching preview, authorization, sequential processing, the delete variant, and a no-retry rule. Minor gaps remain: overtime is not mentioned and no response format is indicated.
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 92%, so the schema already documents individual parameters well and the baseline is 3. The description only incidentally reinforces the work_time_action=delete behavior and retry policy; it does not add substantial parameter-level meaning beyond the schema.
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: submit one real application after its matching preview, distinguishing it from preparation or cancellation workflows. However, it names only 'leave or work-time correction' while the schema also allows 'overtime', so it is not fully aligned with the accepted kinds.
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 gives clear preconditions: use only after the matching preview and only when the exact action or an active scoped business policy is user-authorized. It also states that an authorized date set may be processed sequentially without per-item confirmation. It does not explicitly contrast with sibling commit tools like cancel/withdraw, but 'matching preview' identifies the correct workflow.
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?
While annotations already indicate read-only, non-destructive, and idempotent behavior, the description adds valuable context: it returns a 'binding fingerprint' and specifically does not withdraw, plus it targets 'pending' applications. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, tightly worded sentence that front-loads the core action and result. No filler or redundant information, making it highly concise while retaining essential details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple single-parameter schema, strong annotations, and clear description of the return value ('binding fingerprint'), the description is largely complete. The term 'binding fingerprint' is not elaborated, but the tool's role in a prepare/commit flow is evident.
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 fully covers the only parameter (id) with a clear explanation ('The numeric No. shown in the freee application list'). The tool description adds no additional parameter semantics, so 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's action ('Read'), the specific resource ('one exact pending personal application'), and the outcome ('return a binding fingerprint without withdrawing it'). This distinguishes it from sibling tools like commit_withdraw, 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 use as a preview step before withdrawal ('without withdrawing it'), but does not explicitly mention alternatives or when not to use. It lacks direct comparison to other tools such as prepare_cancel or detail, leaving usage guidance largely inferred.
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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description reinforces this with 'No application is changed.' It adds meaningful behavioral context: the tool returns a binding fingerprint, may bypass per-item confirmation under exact instructions or policies, and performs safety checks that can block the item. The fingerprint is mentioned but its format and lifecycle are not explained, which keeps this from being a 5.
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-loads the core purpose in the first sentence. The subsequent sentences add necessary behavioral constraints, but the final sentence is somewhat dense with domain terms and conditional logic. Overall every sentence earns its place, though the structure could be slightly clearer for an agent scanning quickly.
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?
There is no output schema, so the description reasonably explains that a binding fingerprint is returned and that no changes are applied. It also covers the important cross-application consistency check for 休暇 and 勤務時間修正. It does not fully explain what the fingerprint is or how the agent should use it afterward, but given the absence of an output schema, the description provides adequate context for invoking the tool correctly.
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 input schema already fully documents id and action, including the enum values for approve and return. The description does not add substantial parameter-level detail beyond confirming the action types are 'approval or return action.' This matches the baseline of 3 when structured schema carries the parameter documentation burden.
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 and resource: 'Read and preview one available approval or return action.' It also distinguishes this from the commit sibling by explicitly saying 'No application is changed' and framing the tool as a preview that returns a fingerprint. This clearly separates it from freee_approval_commit_action and other prepare/commit siblings.
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 conveys when this prepare step is appropriate: before committing an action, especially when an exact instruction or active scoped policy lets the agent skip per-item confirmation. It also includes a specific pre-approval check for 休暇 applications against same-date 勤務時間修正 entries. It does not explicitly name 'use freee_approval_commit_action next,' but the preview-vs-commit distinction is clear from the wording and sibling context.
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?
Annotations already declare readOnly, idempotent, and non-destructive; the description adds that no credentials/secrets are returned and explains the behavior when Playwright credentials are missing, which is valuable context beyond the annotations. This helps the agent understand failure modes and safety guarantees.
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 clear sentences, front-loaded with the main purpose, no fluff. Each sentence adds distinct information: the first states what it does and a safety guarantee, the second describes the behavior in a missing-credential scenario. Perfectly sized for a simple tool.
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 status check with rich annotations and no output schema, this description covers the essential behaviors: what it does, safety guarantees, and failure mode. It could mention the success return format but that's not critical given no output schema and the clear purpose.
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?
With zero parameters, the description has nothing to compensate for; it appropriately doesn't mention parameters. Baseline for zero-param tools is 4, and the description lives up to that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Verify' and names the resource 'freee authentication', clearly distinguishing it from sibling status tools like freee_clock_status and freee_backend_status. It also adds the important caveat about not returning credentials, which further sharpens the purpose.
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 it should be used to check authentication state but provides no explicit guidance on when to choose it over sibling tools or when not to use it. The conditional about missing credentials gives some context but no alternatives are mentioned.
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?
Annotations already mark this as destructive, non-read-only, and non-idempotent. The description goes further by disclosing that the agent may validate the fingerprint and continue without a second prompt, and by warning never to retry an unknown write. This is meaningful behavioral context beyond the annotations and does not contradict them.
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 with no filler, front-loaded with the core action and followed by essential behavioral guardrails. Every clause earns its place, including the authorization condition and the retry warning.
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 destructive, non-idempotent commit tool with no output schema, the description plus schema cover authorization, sequencing, fingerprint handling, and safety. It does not describe post-commit outcomes or error responses, but that is not required given the annotations and open-world hint.
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%, and the schema already gives rich semantics for action, period, confirm, and fingerprint. The description adds only a brief echo of fingerprint validation ('validate the fingerprint'), so it does not materially improve on 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?
States a precise action ('Submit or withdraw'), a specific resource ('one real monthly attendance application'), and a clear phase ('after its matching preview'), which distinguishes it from the matching prepare tool and other commit tools. The scope is unambiguous, so an agent knows exactly what this tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear when-to-use context: after the matching preview, only when the exact action or an active scoped business policy is user-authorized, and with fingerprint validation. It does not explicitly name sibling alternatives or state when not to use it, but the sequencing and authorization conditions are strong enough to guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only and non-destructive behavior. The description adds the valuable context that this is a preview returning a binding fingerprint and that no application is changed, enriching the behavioral picture without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences cover purpose, outcome, and safety guarantee with no redundant wording. Every phrase earns its place.
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 2-parameter tool with rich schema annotations and no output schema, the description covers the essential elements: the action type, the read-only nature, and the fingerprint return. A minor gap is that it does not mention that this should precede a commit step, but that is inferable from the sibling tools.
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% and both parameters have detailed descriptions (action enum with meanings, period pattern and behavior). The tool description adds little beyond what the schema already conveys, so the baseline 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 reads and previews a monthly submit or withdrawal action, with a specific outcome (returning a binding fingerprint). This distinguishes it from sibling commit tools and other monthly actions.
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 indicates this is a preview-only step and explicitly states that no application is changed, which tells the agent when to use it (before committing) and when not to use it (to actually apply changes). However, it does not explicitly name the commit counterpart for follow-up.
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?
Annotations already indicate read-only and idempotent behavior, and the description reinforces this with 'without changing freee'. It adds extra behavioral context beyond annotations by explaining the period parameter behavior ('Playwright selects and verifies that work month before reading') and the fallback to the currently selected month, which is useful for understanding how the tool operates.
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 the core action, the resource, and the non-destructive nature immediately. The Japanese term '月次勤怠締め' is specific and meaningful in context, and the sentence is compact without sacrificing key information.
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 optional parameter, no output schema, strong annotations), the description covers the essential behavior: reading a specific month and its available actions. It does not detail the output format or enumerate what 'available actions' might be, but it provides sufficient completeness for a status-checking tool among well-defined siblings. A slightly more explicit description of the returned data would justify a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds semantic value by clarifying that the optional period parameter corresponds to a 'requested' month, while omitting it means the tool reads the 'currently selected' month. This helps the agent understand optionality and fallback behavior, going beyond the schema's straightforward pattern 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 uses a specific verb ('Read') with a clear resource ('personal 月次勤怠締め month') and scope ('and its available actions'). It also clarifies that the operation does not alter anything, which distinguishes it from sibling prepare/commit tools. This is a clear, unambiguous purpose.
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 a read-only inspection use case but does not explicitly state when to use this tool versus alternatives like freee_monthly_prepare_action or freee_monthly_commit_action. It mentions 'without changing freee' but lacks explicit when-to-use or when-not-to-use guidance, so usage must be inferred.
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?
Annotations already indicate destructiveHint=true and idempotentHint=false, so a write with no retry is expected. The description adds valuable behavioral guidance beyond the annotations: the agent may validate the fingerprint and proceed without a second prompt, and it must never retry an unknown write, which is critical safety context for a destructive mutation.
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 carry the entire behavioral contract: when to act, what the agent may do, and what it must never do. The safety-critical retry warning is front-loaded in a short final clause, and there is no filler or repetition of schema details.
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 destructive, non-idempotent write with no output schema, the description covers the trigger condition, authorization requirement, fingerprint validation, and retry prohibition. It is slightly light on explicit linkage to the prepare_withdraw sibling and on what a successful withdrawal returns, but the schema and wording together give enough context to call it correctly.
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%, and each parameter already has a clear description, so the description does not need to re-explain them. It lightly reinforces the fingerprint's validation role and the confirm parameter's user-authorization meaning, but does not add significant semantic value 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 names a specific action ('Withdraw') and resource ('one real personal application'), and 'after its matching preview' clearly positions it as the commit counterpart to a prepare step. This differentiates it from the many personal-application sibling tools, especially prepare_withdraw and the commit_create/commit_cancel variants.
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 explicitly frames when the tool is appropriate: after the matching preview and only when the exact action or an active scoped business policy is user-authorized. It does not explicitly name alternative tools or say 'use commit_cancel instead for cancellation,' but the preview-commit pairing conveys the intended usage context.
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?
Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds valuable behavioral context beyond annotations by specifying the tool's special reporting of withdrawal/cancellation availability, which is not inferable from structured data alone.
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 redundant words. It efficiently communicates the action, scope, and unique purpose.
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 tool with one parameter, strong annotations, and no output schema, the description provides sufficient context. It states the read purpose and the key reporting behavior, though it does not detail error cases or exact return format, which is acceptable given the tool's simplicity.
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% with a clear description of the 'id' parameter ('The numeric No. shown in the freee application list'). The tool description does not add further parameter detail, but the schema already carries the semantic load, so baseline 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 specifically states the action ('Read one application'), the resource ('application submitted by the current employee'), and a unique behavior (report whether withdrawal/cancellation is available). This distinguishes it clearly from sibling tools like list, prepare, or commit actions.
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 when needing details and availability status of a single application, but does not explicitly state exclusions or alternatives like 'use freee_personal_applications_list to list all'. The context is clear enough for an agent to infer 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?
The description adds real behavioral substance beyond the annotations: validation without submission, a binding fingerprint, and the clarification that delete previews a correction request rather than raw record deletion. This aligns with the readOnlyHint/idempotentHint/destructiveHint annotations without contradicting them. It does not cover error cases or fingerprint lifecycle, but those are not core to the tool's safety profile.
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 with no filler. The first sentence front-loads the verb, resource, scope, and outputs; the second handles the non-obvious delete special case. Nothing in the description repeats the schema or annotations unnecessarily.
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 there is no output schema, the description does explain the primary return content: route, exact values, and a binding fingerprint. Conditional parameter rules and the options-tool-first guidance live in the schema, which is acceptable given 100% coverage. It stops just short of explicitly telling the agent to pass the fingerprint to commit_create, leaving that to inference.
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 schema covers 100% of parameters, so the description does not need to repeat them. It still adds meaning for work_time_action=delete by stressing the exact Japanese label and emphasizing that this is a correction-request preview, not a direct deletion. That semantic clarification is useful, though modest on top of an already fully documented 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 a specific action — fill and validate a leave or work-time correction form without submitting — and names concrete outputs: route, exact values, and a binding fingerprint. This clearly distinguishes prepare_create from commit_create and other application tools. The only slight omission is that overtime is not mentioned, but the schema explicitly handles that.
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?
It clearly frames the tool as a preview/no-submit step and gives a conditional rule for work_time_action=delete. However, it never explicitly names alternatives such as commit_create or the options tool, nor states 'use this before committing' or 'use that to actually submit.' The usage context is implied rather than directly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as destructive and non-read-only, but the description adds valuable behavioral detail: every call recomputes the payment-month/work-month mapping, matches the complete monthly review and fingerprint, and stops before any click if mapping is ambiguous or changed. The explicit 'never retry an unknown write' guidance is especially useful for a destructive tool.
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 front-loaded with the core action and uses three focused sentences. Each sentence adds important operational or safety context, though the phrase 'real 月次勤怠締め' and some policy phrasing could be tightened without losing meaning.
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 destructive single-item commit tool, the description supplies the critical context: authorization requirements, sequential use allowance, fingerprint matching, mapping recomputation, and no-retry behavior. It is complete enough for safe invocation, though it does not explicitly reference the prepare tool by name or describe the success response.
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 reinforces the confirmation and fingerprint concepts but does not add substantial meaning beyond the schema. 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 opens with a specific verb and resource: 'Approve or return one real 月次勤怠締め application.' The name and title also clearly indicate this is the commit step for a monthly approval action, distinguishing it from prepare/review siblings. It is not tautological and gives the agent a precise sense of what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states when to use the tool: only after authorization for the exact action or an active scoped business policy. It also gives explicit negative guidance: ambiguous or changed mapping stops before any click and unknown writes must never be retried. However, it does not explicitly name the alternative prepare tool or say 'use the prepare action first,' though the schema's fingerprint reference implies this.
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?
Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds valuable context beyond these: that the form is validated, that nothing is submitted, and that it returns the original application, cancellation reason, route, and a binding fingerprint. This clarifies the operation's behavior and output without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and resource, and every word earns its place. It avoids repetition of schema details and communicates scope, validation, and return content efficiently.
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?
With only two simple parameters and no output schema, the description is fully complete. It names the key return elements (original application, reason, route, fingerprint) and the non-submitting behavior. The complexity is low, and the description covers all essential aspects an agent needs.
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 does not meaningfully enhance parameter understanding beyond the schema; it only loosely references the cancellation reason and the target application. No new syntax or additional meaning is 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 uses specific verbs ('Open and validate') and a specific resource ('cancellation form for one exact approved personal application'), clearly distinguishing it from submit/commit tools. The phrase 'without submitting it' explicitly differentiates it from commit_cancel.
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 this is a preview/validation step before a cancellation commit, stating 'without submitting it'. It specifies the target is 'one exact approved personal application', giving context for when to use it. However, it does not explicitly name alternatives or exclusions, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate a non-read-only, non-idempotent, open-world write; the description enriches this by disclosing the real-world side effect ('real punch'), the mandatory authorization requirement, and the no-retry policy for unknown writes. It also explains that the agent may validate the fingerprint and proceed without a second prompt, which is important behavioral 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?
Two sentences carry a large amount of decision-relevant information: the core operation, the sequencing relative to preview, the user-authorization condition, and the safety rule. It is front-loaded and free of 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 non-idempotent write with no output schema, the description covers the invocation-critical requirements: when to call, authorization, fingerprint validation, and no-retry behavior. It does not describe the return payload or mismatch handling, but the included guidance lets the agent invoke correctly and avoid unsafe calls.
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 high (75%) and the individual parameter descriptions in the schema are already detailed, especially for fingerprint and confirm. The description adds no new parameter-level meaning beyond restating the authorization and preview concepts; 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 states a specific operation: 'Create one real punch after its matching preview', using a precise verb and resource. It clearly differentiates this tool from the prepare/status siblings by emphasizing the real punch versus the preview and the commit-after-preview sequence.
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 explicit call conditions: after the matching preview and only when the action or an active scoped business policy is user-authorized. It also gives explicit prohibitions ('never call without authorization or retry an unknown write'), although it does not name the prepare tool as an alternative by name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context beyond these: it specifies the exact data returned (applicant, dates, content, etc.), and for 勤務時間修正 it discloses the structured workTimeChange.before/after fields, including the semantics of null time fields (freee displayed 未入力). This enriches the agent's understanding of tool output and edge cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: two sentences. The first sentence front-loads the core purpose and output summary. The second sentence adds a specific sub-type behavior in a tight, information-dense manner without fluff. Every word contributes value.
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 read tool with a single parameter and no output schema, the description adequately covers the return content (applicant, dates, content, reason, comments, approval route, automatic checks) and special case (勤務時間修正). It also explains the null semantics, which is essential for interpreting results. There is no missing critical behavior for the intended 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 coverage is 100%: the only parameter 'id' has a description ('The numeric No. shown in the freee application list'). The tool description does not add any parameter details beyond the schema. Since the schema already fully documents the parameter, the baseline 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 'Read one application' with a specific verb and resource, and enumerates the returned components (applicant, dates, content, reason, comments, approval route, automatic checks). This differentiates it from sibling list/detail tools like freee_approvals_list and freee_personal_application_detail. The mention of a supported 勤務時間修正 subtype further specifies scope.
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: when you need to read a single application by id. It states 'Read one application', which gives clear context. However, it does not explicitly mention when not to use it or point to alternatives (e.g., 'for listing, use freee_approvals_list'). Despite lacking explicit exclusions, the context is unambiguous.
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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds 'No application is changed' to reinforce the safe read-only nature, and clarifies that data is scoped to the current employee with an optional date affecting leave types, providing contextual value beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no redundant phrasing. The first sentence states the action and scope; the second sentence provides safety reassurance. Every word earns its place.
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 read-only tool with one optional parameter and no output schema, the description fully explains what is read, who it applies to, and that no changes occur. The potential return values are implicitly clear from the description, so no additional explanation is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage for the single optional date parameter, so baseline is 3. The description adds meaning by stating 'for an optional date, the leave types configured', which clarifies the date's specific role in determining leave types, going beyond the schema's basic 'Optional date in YYYY-MM-DD 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?
Description clearly states it reads application types enabled for the current employee and leave types for an optional date. This is a specific verb+resource, distinguishing it from sibling list/detail tools like freee_personal_applications_list and freee_personal_application_detail by focusing on configuration/options.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context that this tool is for reading available types/options, not for creating, updating, or cancelling applications. It does not explicitly name exclusions or alternatives, but the scope ('enabled for the current employee') implies when it would be used.
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:

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

Score Badge

Copy to your README.md:

[![freee-mcp MCP server](https://glama.ai/mcp/servers/newbdez33/freee-mcp/badges/score.svg)](https://glama.ai/mcp/servers/newbdez33/freee-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/newbdez33/freee-mcp'

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