Skip to main content
Glama

oto_guide_v2

BETA. Same surface as oto_guide, with a STRICT write contract: op=write, op=delete and op=restore REQUIRE expected_rev — read first (op=read returns rev), so a guide or readme someone else wrote meanwhile is never overwritten unseen. Load or author oto INSTRUCTION PROSE — a how-to loaded when needed, or a readme injected into every session. Two axes: scope = platform | tenant | org | group | user (who writes it, whom it applies to) and delivery = 'on-demand' (default: a guide you load for a task) | 'init' (a readme concatenated into what you receive at handshake). op=list → the on-demand catalog you can see (platform ∪ your org ∪ your own) ; op=read (slug, optional scope) → its markdown body and rev ; op=write / delete (slug, scope, body_md, title?, description?) → author for the PLATFORM (platform admin), a TENANT (its tenant admin or a platform admin; owner_id = the tenant slug, which also reads it back), your ORG (org admin), your TEAM (team lead) or YOURSELF (scope=user, the default). With delivery='init' the slug is canonical per scope — omit it (the user's own readme is scope='user', delivery='init'; an empty body clears that layer). op=patch (slug, scope, mode, ONE target: section or region) → edit ONE region of an existing on-demand guide WITHOUT re-sending its body (how you append to a long guide or a journal): same grammar as oto_doc op=patch, same writers as op=write, and the reply is a receipt, not the body. expected_rev = the rev of op=read: refused if the guide changed since. op=write / delete take expected_rev too (the rev of op=read — readmes included; absent when there was nothing): refused 409 conflict if someone changed it since, nothing written. VERSIONS: what a write, patch or delete replaces is KEPT (30 days, or the 50 most recent per guide, whichever keeps more). op=revisions (slug, scope) → the kept versions, newest first: rev, replaced_at, replaced_by, reason, size — a deleted guide included ; op=read with rev → that version's content ; op=restore (slug, scope, rev) → writes that version back as a NEW write: same writers and same expected_rev guard as op=write, and the version it replaces is kept in turn. Reading versions takes the right to read the guide. Read the relevant guide BEFORE a non-trivial task (e.g. bulk-load). This is PROSE: a repeatable process with slots is a procedure (oto_procedure), and what oto knows about the user is their profile card (oto_profile).

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "oto_guide_v2"
  }
}

Input Schema

NameRequiredDescriptionDefault
opNolist
revNoop=read: the `rev` of a KEPT version (listed by op=revisions) → that version's content instead of the current one. op=restore (required): the version to write back.
_orgNo
modeNoop=patch: replace (default) | append | prepend | delete (the target, heading included; no `body_md`).
slugNo
scopeNo
titleNo
regionNoop=patch: `preamble` = what precedes the first heading, instead of `section`.
body_mdNo
sectionNoop=patch: the heading text of the section to edit (level and case ignored); `body_md` = its body, without the heading.
deliveryNoon-demand
owner_idNo
descriptionNo
expected_revNoop=patch|write|delete|restore: the `rev` from op=read (or a previous write) — refused 409 `conflict` if the guide changed since; `absent` = nothing there yet.

Schema Changelog

Changes observed during successful MCP inspections.

No schema history has been recorded yet.

TDQS

A4.4/5.0
Behavior4/5

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

With no annotations, the description carries the full burden and does so well: it discloses the optimistic-concurrency guard (409 conflict, `absent` sentinel), the permission model per scope, version retention ('30 days, or the 50 most recent per guide'), and that op=patch returns a receipt rather than the body. Gaps remain on what a successful write returns (only patch's return is described) and on any rate or size limits, so it stops short of 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.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The critical constraint (expected_rev required for write/delete/restore) is front-loaded, but the remainder is a single very long paragraph dense with backticks and capitals, with no line breaks or sections for the eight distinct ops. It is information-rich yet hard to scan, so it does not earn high marks on structure.

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 14-parameter tool with no annotations and no output schema, the description is unusually complete: it covers every operation's inputs, the write-conflict protocol, versioning, and permission tiers. It stops short of explaining op=list's return shape and the metadata parameters (title, description, _org), which an agent may still need.

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 only 36%, so the description must compensate, and it largely does: it explains scope values, delivery modes, owner_id as the tenant slug, expected_rev's origin and refusal semantics, mode's four values, and section vs region for patch. Left unexplained are title, description, _org, and the exact slug conventions for non-init scopes.

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?

A specific verb-and-resource statement: 'Load or author oto INSTRUCTION PROSE' with the two axes (scope, delivery) named immediately. It distinguishes itself from the sibling oto_guide ('Same surface as oto_guide, with a STRICT write contract') and from oto_procedure and oto_profile at the close, so an agent can route without opening the schema.

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?

Explicit operating guidance: 'Read the relevant guide BEFORE a non-trivial task (e.g. bulk-load)', plus a decision rule for the alternatives — 'a repeatable process with slots is a procedure (oto_procedure), and what oto knows about the user is their profile card (oto_profile)'. It also states when delivery='init' vs 'on-demand' applies and who may write at each scope.

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.

Resources