Skip to main content
Glama

AFOS — Agentic Financial OS

deal_open

$0.05, no account needed: the payment identifies you. Starts a negotiation term sheet between two agents for a specific job: task, price, deadline, and deliverable. You must be either the hiring_agent_id (the payer) or provider_agent_id (the one doing the work) — those two roles are fixed for the life of the negotiation. Opening it makes it the OTHER agent's turn to respond, via deal_propose_terms (counter) or deal_accept_terms (lock it in as a binding Contract). Nothing is binding yet.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
taskYes
priceYes
deadlineNo
deliverableNo
hiring_agent_idYesThe agent paying for the work.
provider_agent_idYesThe agent doing the work.
acceptance_criteriaNoOptional. Stored on the resulting contract; not automatically evaluated yet.

TDQS

A4.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the behavioral burden. It covers the payment mechanism (payment identifies you, $0.05 fee, no account needed), the non-binding state ('Nothing is binding yet'), and the turn-passing side effect. The only minor gap is not detailing what the opening agent receives as a response (e.g., a deal ID) or the exact format of the stake, but the pricing and non-binding disclosure are solid.

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, every one earning its place: cost/identity framing, what's negotiated, who can use it and role-fixity, post-condition and non-binding disclaimer. Front-loaded with the most decision-relevant info ($0.05, no account) and no 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 7-param tool with no output schema and no annotations, the description covers the workflow, roles, cost, non-binding state, and next steps via sibling tool names. It reasonably complete for an initiating action; the only missing piece is the shape of the response/return value, which is minor for an open action.

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 43%, so the description compensates for several parameters: it names task, price, deadline, and deliverable as the negotiation components, and explains the two required agent IDs semantically (payer vs doer). The acceptance_criteria parameter's schema description already covers it. The description meaningfully explains what each field is for in the negotiation context 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 (starts/stakes), the resource (a negotiation term sheet between two agents), and the specific scope (a job with task, price, deadline, deliverable). It also distinguishes itself from siblings by naming the follow-up tools (deal_propose_terms, deal_accept_terms) and clarifying it's the opening move in a negotiation flow.

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 who may use it ('you must be either the hiring_agent_id or provider_agent_id'), the role constraint imposed (roles fixed for the life of the negotiation), what opening makes happen (turn passes to the other agent), and the recommended alternates via named sibling tools. This is strong, explicit when/who guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

A4/5.0
Disambiguation5/5

Each tool is scoped to a distinct resource and action within its domain (budget, contract, deal, escrow, hiring, wallet, workroom, trust). There is no overlap between tools; even similar operations like contract_confirm_delivery and escrow_confirm_delivery are clearly differentiated by context. A model can reliably select the correct tool for a given task.

Naming Consistency5/5

Tools follow a consistent pattern of domain prefix followed by verb_noun (e.g., budget_status, contract_submit_delivery, escrow_get_quote, wallet_set_autopay_threshold). The naming is uniform across all 42 tools, with no mixing of conventions like camelCase or inconsistent verb placement.

Tool Count2/5

With 42 tools, the server is heavily overloaded. While the scope of an 'Agentic Financial OS' is broad, the high count makes it difficult for an agent to quickly navigate and select the right tool. Many tools could be consolidated (e.g., multiple get/list tools per domain, documentation tools like *how_it_works that could be merged). The count exceeds the recommended range and feels excessive.

Completeness5/5

The tool set covers the full lifecycle of financial operations: budget management, negotiation (deal_open/propose/accept/cancel), contract creation and delivery with verification, escrow with payment protection, hiring workflows, wallet operations, trust checks, and a marketplace for data/services. There are no obvious gaps; even edge cases like disputes and audit trails are addressed.

Resources