contract_get
Get a specific contract by ID, including signers and their status.
Input Schema
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
Get a specific contract by ID, including signers and their status.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral burden. The verb 'Get' implies a safe read operation with no side effects, and the description discloses some returned content. But it does not address permissions, errors, or any other behavioral traits, which is a modest gap for a one-parameter read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no filler. Every word contributes: 'Get', 'specific contract', 'by ID', and the signers/status detail all add distinct value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read operation with exactly one required parameter and no output schema, the description is largely sufficient. It explains what the tool returns at a high level. Minor omissions like error behavior or exact response structure are not critical for a basic get-by-ID tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate, but it only repeats that the tool works 'by ID.' The input schema's id pattern (^[cC][^\s-]{8,}$) is restrictive and potentially confusing, yet the description does not clarify what constitutes a valid contract ID or how the id is used beyond the obvious.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') with a specific resource ('specific contract by ID') and adds meaningful detail about the returned data ('including signers and their status'). This clearly distinguishes the tool from siblings like contract_list, contract_create, and contract_cancel.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'specific contract by ID' implies this is the tool to use when you already have a contract identifier and need one contract, rather than a list. However, it does not explicitly state exclusions or name alternative tools, leaving some usage inference to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add one secure layer between your agents and this server.
Each tool targets a unique resource-action pair: contract operations are clearly separated from template operations, and actions like create, get, list, update, send, cancel, archive, and upload are distinct. There is no meaningful overlap or ambiguity between the tool purposes.
Tool names follow a consistent noun_verb pattern: contract_create, contract_list, template_get, template_upload, etc. This makes the API surface predictable and easy for an agent to navigate.
Twelve tools is well-scoped for a document-signing server covering both contracts and templates. Each tool serves a clear lifecycle purpose, and the count feels neither bloated nor thin.
The toolset covers the core contract lifecycle (create, update, send, cancel, get, list) and template lifecycle (create, update, archive, upload, get, list). Minor gaps exist, such as no way to permanently delete a contract, restore an archived template, or download signed contract documents, but these are not critical for the main workflows.