papers
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@papersShow the trial balance and review notes for the Smith engagement."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
papers
Open interface for accounting working papers and engagements.
papers lets software and AI work with an engagement through portable accounting concepts — engagements, trial balances, adjustments, working papers, review notes — instead of one vendor's file format and field IDs. Caseware is the first adapter.
Status: early development. The concepts and the adapter contract are defined. The Caseware bridge is specified but not implemented, and every capability it reports is
false. Treat this as infrastructure under construction, not production software.
The idea
A compilation or a year end is the same shape of work everywhere: a trial balance arrives, accounts get grouped, balances get supported by evidence, questions get raised and cleared, adjustments get proposed and reviewed. The concepts are portable. Only the storage is not.
So papers separates three things:
The concepts — what an engagement is made of, in accounting terms. Nothing in src/concepts names a vendor, a file format or a field ID. When a concept cannot be expressed without one, it belongs in an adapter.
The adapter contract — what a given system can actually do, declared rather than assumed, and how a mutation is planned before it is performed.
The adapters — the translation, and the only place vendor specifics live.
Related MCP server: Ledger MCP
Two rules that shape the contract
Capabilities are declared, never assumed. A caller asks what an adapter supports before asking it to do anything. A desktop Working Papers bridge and a future Cloud adapter will not support the same set, and failing halfway through a write is not an option in a file a firm is professionally responsible for.
validate is the default; commit is a separate decision. Every mutation is planned first and returns what it would change, with the warnings a reviewer should see. Nothing reaches a firm's file until a caller asks for it explicitly — which in practice means an accountant did.
Two smaller ones fall out of the same concern. Money is integer minor units, because a trial balance has to tie exactly and floats do not. And every value carries where it came from — adapter, document, page, checksum — so a reviewer can get back to the source rather than trusting the number.
Grouping is the firm's, not ours
Account.group is a free string on purpose.
Grouping numbers differ between firms, and between files at the same firm. There is no universal Caseware grouping to learn. A fixed enum here would quietly mistranslate one firm's 240 into another's, which is exactly the class of error nobody catches until a financial statement is wrong.
The mapping belongs to the firm's own methodology, informed by the prior-year file and the accounts themselves, and confirmed by a person when it is uncertain. papers carries it; it does not decide it.
The Caseware bridge
Working Papers is a desktop application. Firms run it on Windows, often through Citrix, against files on a network share. Nothing outside the firm can reach it directly.
So the adapter speaks to a small bridge running inside the firm's environment, beside the files, holding whatever licensed components Caseware requires:
papers (MCP) → CasewareBridgeAdapter → documented bridge protocol
│
── firm environment ───┼───────────────
▼
bridge → Working PapersThat split is also a licensing boundary. The protocol and the adapter are ours and are open. Anything linking Caseware's own SDK belongs to the bridge, distributed separately under the terms Caseware's agreements require.
Before using this across more than one firm, read docs/security.md. Caseware's API Usage Policy permits a customer to engage a third-party developer for its own internal purposes, and separately requires a formal partner review and written approval before an integration is commercialized or offered to multiple firms.
Install
npm install
npm run buildRun the MCP server over stdio:
PAPERS_ADAPTER=caseware npm startWith no PAPERS_ADAPTER, the server starts and reports no capabilities — useful for inspecting the tool surface without touching a firm's files.
Related
fisc — the same idea for professional tax software: Taxprep, DT Max.
License
Available Tools
5 toolsget_capabilitiesA
Describe the configured adapter and what it supports
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does indicate a read-only introspection action ('Describe') with no side effects, which is helpful. However, it does not disclose the output format, whether any configuration or permissions are needed, or what exactly will be listed in 'what it supports'. The behavior is not contradictory, just underexplained.
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, compact sentence with no filler. The action ('Describe the configured adapter') is front-loaded, and the second clause ('what it supports') adds relevant scope without redundancy. Every word earns its place.
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?
Given zero parameters and no output schema, the description is the only source of behavioral context. It states the tool's purpose but leaves the return value's shape and the precise extent of 'supports' unspecified. An agent could call the tool and be surprised by the response structure, but for a simple introspection call this is an acceptable gap rather than a fatal one.
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?
The tool has zero parameters and an empty input schema, so there is nothing for the description to add. Per the rubric, zero parameters earn a baseline of 4. The description correctly avoids inventing parameter details that do not exist.
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 states a clear verb ('Describe') and resource ('configured adapter and what it supports'), making the tool's purpose understandable. It is distinct from sibling tools like list_engagements and propose_adjustment, which clearly concern different resources. However, the phrase 'what it supports' is somewhat vague and could be more explicit about the kind of capabilities being described.
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 description implies the tool should be used to inspect adapter capabilities, but it gives no explicit guidance on when to use it versus alternatives, nor does it mention exclusions or prerequisites. The sibling tools are unrelated enough that confusion is unlikely, but the lack of any 'use this when' statement leaves the guidance at the level of implication.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_trial_balanceC
Read a trial balance for an engagement
| Name | Required | Description | Default |
|---|---|---|---|
| as_of | No | ISO 8601 date; defaults to period end | |
| engagement_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full behavioral disclosure burden. 'Read' signals a non-mutating operation, but the description gives no detail about return contents, error behavior, data scope, or defaults such as as_of behavior.
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?
The description is a single clear sentence with no wasted words. The key action and target resource are front-loaded, making it easy to scan.
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?
The tool has no output schema and no annotations, so the description is responsible for explaining what the agent can expect. It does not describe the trial balance contents, return format, or behavior of the optional as_of parameter, leaving notable gaps for a tool this minimal.
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 only 50%, with engagement_id left undocumented. The description adds no parameter-level meaning beyond implying engagement context, so it does not compensate for the missing schema coverage.
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 clearly identifies the verb ('Read') and resource ('a trial balance for an engagement'), so an agent can understand the core function. It stops short of a 5 because it does not explicitly distinguish itself from sibling tools like get_capabilities or list_engagements.
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 description gives no guidance on when to choose this tool over alternatives, nor any exclusions or prerequisites. The intended use is inferable from the name and phrasing, but the tool itself does not state it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_engagementsB
List engagements visible to the adapter
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that engagements are 'visible to the adapter' but does not clarify read-only behavior, output shape, pagination, ordering, or failure modes. 'List' implies reading, but little else is disclosed.
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?
The description is a single short sentence that front-loads the verb and resource with no filler. Every word contributes to the meaning.
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 zero-parameter list operation, the description is minimally sufficient to invoke the tool correctly. However, because there is no output schema and no annotations, the return format and the precise meaning of 'engagements' remain unexplained, leaving the description only partially complete.
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?
The tool has zero parameters and the input schema is fully empty, so there is no parameter burden for the description to carry. The baseline of 4 for a no-parameter tool applies.
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 'List' and names the resource 'engagements', adding a scope qualifier 'visible to the adapter'. It is distinguishable from the siblings by name and scope, though 'engagements' is not defined further.
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?
There is no guidance on when to use this tool versus siblings like get_capabilities, get_trial_balance, list_review_notes, or propose_adjustment. The agent must infer usage entirely from the tool name and a one-line description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_review_notesC
Read the review notes on an engagement
| Name | Required | Description | Default |
|---|---|---|---|
| engagement_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates a read operation, but does not disclose ordering, pagination, permission needs, error behavior, or what happens with empty results. This is minimal and leaves the agent with limited expectations.
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?
The description is a single sentence with no filler. The verb and object are front-loaded, and every word contributes to the meaning. It could not be meaningfully shorter without losing information.
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 one-parameter read tool, the description is minimally viable: it states the action and target object. However, with no annotations, no output schema, and no behavioral details, an agent is left without information about return format, ordering, or edge cases. It is adequate but not complete.
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 needs to compensate for the engagement_id parameter. It only says 'on an engagement,' which weakly ties the parameter to the resource, but it does not explicitly explain what engagement_id is, its format, or its role in the request. This is insufficient for a parameter with no schema-level documentation.
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 ('Read') and a clear resource ('review notes on an engagement'), so the core purpose is unambiguous. It does not explicitly differentiate from sibling tools, but the operation is distinct enough from list_engagements, get_trial_balance, and propose_adjustment.
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 description provides no guidance on when to use this tool versus alternatives. There is no discussion of prerequisites, when to prefer it over another tool, or when not to use it. The engagement context is implied but no explicit routing is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
propose_adjustmentA
Plan an adjusting entry. Defaults to validate: nothing is written unless mode is commit.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | validate | |
| lines | Yes | Lines must sum to zero | |
| rationale | No | Why this entry exists, for the reviewer | |
| description | Yes | ||
| engagement_id | Yes | ||
| idempotency_key | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explicitly discloses the critical side-effect behavior: 'nothing is written unless mode is commit.' Since no annotations are provided, this is essential and well-handled. It does not disclose other behavioral aspects like validation errors or idempotency behavior, but the core write-safety concern is addressed.
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?
The description is one concise sentence, front-loading the tool's purpose and following with the key safety behavior. Every word earns its place; there is no redundancy or filler.
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 tool with 6 parameters, no annotations, and no output schema, the description is too sparse to be complete. It covers the central write-safety behavior but omits context around required inputs, validation semantics, idempotency, and what a successful plan or commit returns.
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 only 33%, and the description adds no parameter-level meaning beyond the mode default already present in the schema. The 'nothing is written unless mode is commit' line clarifies mode's behavioral effect, but engagement_id, description, rationale, and idempotency_key remain semantically undocumented.
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 states a specific verb ('Plan') and resource ('an adjusting entry'), and the qualifier about validate mode makes clear this is a planning/write tool rather than a read tool. This differentiates it from the sibling tools, which are all read-oriented (get, list).
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 description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites like an existing engagement or trial balance. The only contextual hint is the planning-vs-commit distinction, which is more behavioral than usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v0.1.0- First observed
get_capabilities - First observed
get_trial_balance - First observed
list_engagements - First observed
list_review_notes - First observed
propose_adjustment
TDQS
Each tool targets a distinct resource or action: capabilities, engagements, trial balance, review notes, and adjustments. There is no meaningful overlap between the tools, and the descriptions clearly separate read-only operations from the one planning/write operation.
Tool names follow a consistent verb_noun snake_case pattern: get/list for reads and propose for the adjustment action. This makes the set predictable and easy to navigate.
With five tools, the server is well-scoped for an accounting engagement review workflow. Each tool covers a necessary capability without redundancy or bloat.
The core workflow is covered: discover capabilities, list engagements, inspect trial balance, review notes, and propose adjustments. A minor gap is the lack of a dedicated method to retrieve engagement-level details or view already committed adjustments, but the main workflow is not blocked.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Headless API-first double-entry accounting & bookkeeping engine. 84 MCP tools over HTTP.
Open-source AI accounting skills verified by licensed accountants (tax, VAT, payroll).
Accounting knowledge graphs: SEC XBRL filings, QuickBooks ledgers, reports and forecasts over MCP.
AI agents for bookkeeping, reconciliation, and financial close for SMBs.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceProvides AI assistants with direct access to HLedger accounting data and functionality, enabling natural language queries for balances, reports, journal entries, and financial analysis.4065MIT
- AlicenseNot gradedqualityBmaintenanceProvides double-entry accounting for AI agents, allowing creation of a chart of accounts, posting balanced journal entries, and pulling trial-balance and general-ledger reports via the Ledger API with x402 micropayments.MIT
- FlicenseNot gradedqualityCmaintenanceFinancial data infrastructure for AI agents. Connect to a startup's books to read live P&L and bank balances, review and reclassify transactions, manage the chart of accounts, and connect banking sources.-
- AlicenseAqualityCmaintenanceEnables AI agents to interact with a double-entry ledger, offering tools for account management, balanced journal entries, balance queries, trial balance, and penny-perfect allocation. Built with safety by construction: no update/delete tools, idempotent posting, and an append-only journal.7MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/coalesc/papers'
If you have feedback or need assistance with the MCP directory API, please join our Discord server