Anythink-MCP

Official

by anythink-cloud

Overview Schema Related Servers Score Discussions

Remote

Server Quality Checklist

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

Latest release: v0.2.21
Disambiguation4/5
Most tools have distinct purposes with clear naming. The `cli` tool overlaps conceptually with dedicated tools like `projects_create`, but its description clarifies it is a fallback for commands not covered by dedicated tools. There is minor potential confusion between `login`, `login_google`, and `login_direct`, but they are differentiated by auth method.
Naming Consistency5/5
All tool names follow a consistent `verb_noun` pattern in snake_case (e.g., `accounts_create`, `projects_list`). Verbs like `create`, `list`, `use`, `delete`, `show`, `remove`, `login`, `logout`, `signup` are used uniformly. No mixing of conventions.
Tool Count5/5
The 16 tools are well-scoped for managing the Anythink platform, covering authentication (5 tools), accounts (3), projects (4), configuration (3), and a general CLI fallback (1). The count is appropriate for the domain's complexity without being excessive.
Completeness4/5
The tool surface covers core workflows: authentication, account creation/selection, project lifecycle (create, list, select, delete), and configuration management. Missing explicit update tools for accounts or projects, but the `cli` tool can likely handle those. Overall, no critical gaps that would cause agent failures.
Average 4.6/5 across 16 of 16 tools scored. Lowest: 3.9/5.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 22 commits in the last 12 weeks
- Last stable release on June 28, 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.
Tools from this server were used 5 times in the last 30 days.
This repository includes a glama.json configuration file.
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.
View related servers

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?
No annotations are provided, so the description carries full behavioral burden. It discloses the core action (bypass billing login) but omits details like authentication requirements, side effects (e.g., persisting credentials), or error conditions. The description adds some value but is incomplete for a credential-storing tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two sentences, directly stating the purpose and usage condition. No unnecessary words or repetition. Perfectly front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 5 parameters, no output schema, and no annotations. The description does not explain return values, whether credentials become active immediately, or how to verify success. It covers the core purpose but leaves behavioral gaps typical for authentication tools. Adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter having a description (e.g., orgId as 'Organization/tenant ID', apiKey as 'API key (ak_...)' ). The tool description adds minimal extra meaning beyond the schema, merely restating the condition for use. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('store credentials directly for a project') and distinguishes it from the billing login process, implying a sibling tool for that purpose. The condition for use ('when you already have an org ID and API key or JWT token') is explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit context for when to use this tool (when credentials are already available) and implies an alternative (billing login), but does not name sibling tools like 'login' directly or specify when not to use. This is clear but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses key behavioral traits: resolves project, stores or exchanges credentials, returns profile name/org/URL/auth method. No annotations exist, so the description carries the full burden and does so adequately, though it could mention if existing profile is overwritten.
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 efficient sentences with no wasted words. Front-loaded with the core action, followed by process details and prerequisites. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and 3 params, the description covers purpose, prerequisites, behavior, and return values. It is complete for setting an active profile but could elaborate on output structure or side effects like overwriting.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline 3. The description adds little beyond what the schema already provides for each parameter, such as the automatic token generation for apiKey. No significant extra meaning is added.
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 'Connect to a project and save it as the active profile' with specific verb and resource, and distinguishes from siblings like projects_create or projects_list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides prerequisites (active billing account via accounts_use, project must be Active from projects_list) and the outcome (targets cli commands). However, it does not explicitly state when not to use or provide direct alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses asynchronous provisioning, required billing account, and return fields (id, name, org id, API URL). It does not contradict any annotations (none present) and adequately covers behavioral traits for a creation 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 a single paragraph that is well-structured: main action, prerequisites, behavior, output. Every sentence adds useful information. It is appropriately sized for a creation tool with moderate complexity.
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 no output schema and no annotations, the description covers purpose, prerequisites, async behavior, and return fields. It addresses how to monitor progress and connect. It could mention error handling or billing failure scenarios, but overall it is fairly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds meaningful context beyond the schema: e.g., name is 'human-readable', planId references the 'plans' CLI command, region defaults to 'lon1', accountId defaults to active account, description as optional. This adds value without redundancy.
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 ('Provision') and identifies the resource ('new project') with a clear definition as 'a dedicated, isolated Anythink backend instance'. It distinguishes from sibling tools like projects_list, projects_use, and projects_delete.
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 prerequisites ('Requires platform login and an active billing account') and provides context on asynchronous behavior with polling instructions, along with a reference to connect using 'projects_use'. It mentions alternatives implicitly (accounts_use, projects_list) but does not explicitly state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description adequately conveys read-only behavior and details the return fields (id, org name, billing email, currency, status, active flag). No contradictions.
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?
Four sentences efficiently cover purpose, prerequisites, output, and next steps with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is nearly complete for a parameterless list tool. It covers return fields, prerequisites, and workflow context. Lacks mention of error cases or pagination but is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, and schema description coverage is 100%. Baseline for zero parameters is 4, and the description adds value by noting the prerequisite login requirement, earning a 5.
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 lists billing accounts for the logged-in user, using specific verbs and resource naming, and distinguishes it from siblings like accounts_create and accounts_use by mentioning the workflow.
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?
Explicitly states prerequisite of prior login and suggests using accounts_use after listing. Provides clear context but does not explicitly state when not to use it beyond the implicit purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It explains input format ('full UUID or a unique prefix'), output ('resolved account name and id, or an error'), and intended effect ('set active billing account'). It does not explicitly state side effects or idempotency, but given the simple nature, it is nearly complete.
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?
Three sentences, front-loaded with purpose, then usage guidance, then input/output specifics. No redundant words; every sentence serves a distinct role. Excellent conciseness for a single-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one param, no output schema, no nested objects), the description covers all necessary context: what it does, when to use it, how to provide input, what to expect as output. No gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description essentially repeats the schema's parameter description. No additional meaning is added beyond what the schema already provides, though the usage context is helpful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Set the active billing account that project commands operate on.' It specifies the verb 'Set' and the resource 'active billing account'. It distinguishes from siblings like accounts_list (list accounts) and accounts_create (create accounts), making its unique purpose obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'after login when you belong to more than one account, before using projects_list, projects_create, or projects_use.' It also directs to accounts_list for valid IDs. Provides both procedural context and prerequisite knowledge, leaving no ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses return of session token, but lacks details on side effects like session expiration, rate limiting, or invalidation of prior sessions. Adequate for a basic login tool but could be more transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no extraneous information. Efficient and front-loaded.
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?
Tool is simple, no output schema needed. Description covers purpose, inputs, and return type (session token). Complete for its 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 coverage is 100%, parameters are simple (email, password) and self-explanatory. Description adds minimal value beyond schema, only hinting at return value. 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?
Description clearly states tool logs in with email and password and returns a session token. Distinguishes from sibling by mentioning alternative 'login_google' for Google sign-in.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says when to use (email/password login) and provides alternative (login_google). Offers clear context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so description carries the burden. It discloses that destructive commands need '--yes' to skip confirmation, and suggests adding '--json' for machine-readable output. It warns against including 'anythink' or '--profile'. While it doesn't detail error handling, it covers key behavioral traits for a generic CLI runner.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-organized paragraph. It starts with purpose, then usage guidance, followed by examples and important notes. Every sentence adds value; no unnecessary repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a generic CLI runner, the description covers boundaries, examples, and important flags. With no output schema, it mentions returning output. Could mention potential errors or timeouts, but overall sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with a detailed parameter description that matches the tool description. The tool description adds extra usage examples and context (destructive commands, --json flag) beyond the schema, enriching understanding.
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 runs any Anythink CLI command and returns output. It specifies the tool is for commands not covered by dedicated tools, listing examples like 'entities list' and 'data list posts', which distinguishes it from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'Use this for commands not covered by dedicated tools' and lists those tools (entities, fields, data, etc.). Provides examples and context for menu commands, making usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses key behaviors: opens browser for Google consent, waits for user approval, stores session token. It also notes the stdio-only requirement. However, it omits potential error handling or timeout behavior, preventing a perfect 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?
The description is four sentences, each adding essential information: purpose, browser flow, what it does not do and next steps, and system requirement. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an OAuth login tool with no output schema, the description covers authentication flow, prerequisites (browser, stdio), and required post-login actions. It could additionally mention the return value or error scenarios, but is largely sufficient.
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 input schema has zero parameters and the description fills in by explaining the whole process. The baseline for 0 parameters is 4, and the description adds meaning beyond the empty schema by detailing the browser interaction and follow-up steps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Sign in to the Anythink platform with Google.' It identifies specific verb and resource, distinguishing from siblings like 'login' and 'login_direct' by specifying the Google OAuth method and clarifying that it does not handle account or project selection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly guides when to use the tool: after login, call accounts_list/accounts_use and projects_list/projects_use. It also warns against use on hosted HTTP server due to browser requirement, effectively telling when not to use it and providing follow-up steps.
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?
Despite no annotations, the description fully discloses the destructive and irreversible nature, what gets destroyed (backend instance, database, data), prerequisites (active billing account), and return value (project name and id).
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 sentences, front-loaded with the critical action, and contains no unnecessary words. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no output schema, the description adequately covers behavior, prerequisites, and return value. Minor gap: no mention of error handling or what happens if prerequisites are not met.
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%, but the description adds meaningful context: explains that 'id' can be UUID, name, or unique prefix, and advises to use specific IDs and where to find them. For 'accountId', it clarifies defaulting behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to permanently delete a project and its backend instance, database, and stored data. It differentiates itself from sibling tools (projects_create, projects_list, projects_use) by explicitly being the destructive deletion action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance: confirm with the user first, prefer specific IDs over prefixes, and require an active billing account. However, it does not explicitly contrast with alternatives for non-destructive actions.
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?
With no annotations provided, the description fully carries the burden. It clearly explains the effect (switches the active profile for the cli tool), the prerequisite (profile must exist), and the outcome (confirmation or error if missing). It also mentions the non-destructive nature by noting no re-authentication needed, which implies safety.
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 sentences with no wasted words. It front-loads the action and scope, then provides usage guidance and error handling. Every sentence adds distinct 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?
The description is complete for this simple one-parameter tool. It explains what the tool does, when to use it, prerequisites (profile must exist), how to find valid profiles (config_show), and what the output is (confirmation or error). No output schema is needed because the return is simple text described.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers the single parameter 'profile' with a description, achieving 100% coverage. The tool description repeats the same parameter semantics ('must already exist', 'see config_show') but does not add new meaning beyond the schema. Thus, it meets the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Switch' and the resource 'active project profile'. It distinguishes from similar tools by noting it moves between already-connected projects without re-authenticating, and explicitly references the 'cli' tool and related commands like config_show and projects_use.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use: 'to move between already-connected projects without re-authenticating'. It also states when not to use by emphasizing the profile must already exist, and directs the agent to run config_show to see available names. This provides clear usage context and alternatives.
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?
With no annotations, the description fully carries the burden. It clearly states the tool only deletes the local stored profile and does not revoke the token or affect the project server-side. This is detailed and accurate.
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 very concise, using only three sentences with no filler. It front-loads the main action and provides essential details 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?
Given the tool's simplicity (1 optional param, no output schema), the description fully covers purpose, usage, behavior, and parameter. No gaps remain.
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 sole parameter 'profile' is fully described in the schema, and the description adds value by noting it defaults to the active profile and referencing 'config_show' for names. This exceeds the baseline for 100% 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 clearly states the tool removes saved credentials from local CLI config, using the verb 'remove' and specifying the resource. It distinguishes itself from sibling login/logout tools by explicitly describing the scope (local profile only).
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 use cases: 'disconnect from a project or clear a stale token'. It also clarifies what it does not do (no server-side revocation) and the default behavior when profile is omitted. However, it does not explicitly mention when not to use or alternatives.
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?
With no annotations, the description fully explains behavior: it is a read-only listing operation. It lists all return fields including statuses (Initializing/Provisioning/Active/Suspended/Terminated/Error), which is beyond the input schema. 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?
Two efficient sentences with no wasted words. The main action is front-loaded, and the second sentence packs necessary details (return fields, prerequisites, usage flow) in a structured manner.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description comprehensively covers return values (fields and statuses) and prerequisites. It also integrates with sibling tools, providing a complete usage context for a list operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the parameter's description already states it defaults to the active account. The tool description does not add new meaning about the parameter's format or constraints 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 'List the projects (provisioned backend instances) in a billing account,' using a specific verb and resource. It distinguishes from sibling tools by mentioning that the output is used with 'projects_use' and 'projects_delete'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states prerequisites: 'Requires platform login and an active billing account (set one with 'accounts_use').' Provides clear context on when to use: 'Use this to find a project's id before connecting with 'projects_use' or removing it with 'projects_delete'.'
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?
No annotations exist, so the description carries full burden. It discloses that account creation requires email confirmation, that login will not work until confirmed, and that it is a top-level identity creation without billing/project. This is transparent and aligns with mutation behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single paragraph with purposeful sentences, no redundancy. Front-loaded with purpose, then usage, then behavioral notes. Every sentence serves a function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters, no nested objects, no output schema, the description covers purpose, usage, behavioral constraints, and post-conditions completely. No gaps.
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 baseline is 3. The tool description adds minimal extra context (e.g., email becomes login identifier, password should be strong), but does not significantly enhance understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Register' and the resource 'brand-new Anythink platform account with email and password'. It explicitly distinguishes from sibling 'login' by specifying when to use each (only when no account yet).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use and when-not-to-use: use only if no account, else use 'login'. Also specifies what the tool does not do (create billing/project) and directs to 'accounts_create' and 'projects_create'. Includes post-registration steps (email confirmation, then login).
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?
Despite no annotations, description fully discloses behavior: only removes local credentials and settings, does not delete project or revoke tokens server-side. Mentions return type (confirmation or not-found).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, front-loaded with main action, no extraneous information. Each sentence serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Fully adequate for a simple tool with one parameter and no output schema. Covers scope, side effects, and return messages.
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?
Single 'profile' parameter is already described in schema, but description adds value by referencing 'config_show' for valid names. With 100% schema coverage, baseline is 3; extra context merits a 4.
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 deletes a saved project profile from local CLI configuration. It distinguishes from sibling 'projects_delete' by clarifying scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (remove local profile) and when not (server-side deletion), providing alternative tool 'projects_delete'. Also advises running 'config_show' to see valid profile names.
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?
With no annotations, the description fully discloses behavior: reads local config, makes no network calls, returns specific fields for profiles (name, org id, auth method, alias, platform) and platforms (URLs, billing account, login status). No contradictions.
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. The first provides the core purpose and output; the second gives usage guidance and constraints. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description is complete. It covers purpose, output details, usage context, and safety (no network calls). No gaps remain.
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?
No parameters, so baseline is 4. The description adds value by detailing the return structure, which compensates for the lack of an output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Show the local CLI configuration: all saved project profiles and platform logins, and which of each is active.' It distinguishes itself from siblings like config_use and config_remove by focusing on display rather than modification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly guides when to use: 'Use this to discover profile names for config_use, config_remove, or logout, and to check which project the cli tool currently targets.' Also notes it only reads local config with no network calls, implying safe to use without side effects.
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?
Discloses all key behavioral traits: requires prior login, sets account as active, non-changeable currency, returns id and name. With no annotations, this description fully carries the transparency burden.
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?
Five sentences, each serving a purpose: core action, prerequisite, side effect, return value, practical guidance. No wasted words, front-loaded with key information.
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?
Covers prerequisites, side effects, return values (no output schema), and usage advice. For a simple create tool with three parameters, this is fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds significant meaning beyond the schema: for name, it mentions being shown on invoices; for email, receiving invoices; for currency, the 'cannot be changed later' constraint. Schema coverage is 100% but description enriches all params.
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 creates a new billing account, a specific verb and resource. It distinguishes from sibling tools like accounts_list and accounts_use by focusing on creation and subsequent behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (after login, before project creation), when not to (check existing accounts first), and provides alternatives (accounts_list). The guidance about most users needing one account is valuable.
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:

[![anythink-cli MCP server](https://glama.ai/mcp/servers/anythink-cloud/anythink-cli/badges/card.svg)](https://glama.ai/mcp/servers/anythink-cloud/anythink-cli)

Score Badge

Copy to your README.md:

[![anythink-cli MCP server](https://glama.ai/mcp/servers/anythink-cloud/anythink-cli/badges/score.svg)](https://glama.ai/mcp/servers/anythink-cloud/anythink-cli)

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/anythink-cloud/anythink-cli'

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