Skip to main content
Glama

notebook

Destructive

Stores free-text notes, unit/city assignments, and standing orders that persist across context resets or restarts, and runs standing-order steps at turn start.

Instructions

My memory, kept beside the game per seat and surviving a context reset or a restart: free-text notes, assignments (what a unit or city is for) and standing orders (a unit's plan the harness carries out over the coming turns). Use it for what future-me must know; the game itself holds no plan. Notes and assignments move nothing; a standing order does: give_order and resume_order run its first steps NOW (a move spends this turn's movement, a build starts) and carry on at the start of each of my turns. action, with its args -- remember {text, tag?, replace_id?}: write a note (returns it with its id; new notes ride on the next briefing / finish); recall {tag?, limit?}: list notes; forget {note_id}: delete a note for good. assign {role, purpose, unit_ids? / city_ids?}: give units or cities a purpose that shows in their state rows; assignments: list them; amend {assignment_id, purpose? / role?}; close {assignment_id}. give_order {unit_id, steps, interrupt?, purpose?, replace_id?}: steps is a list of at most 6, in order -- {kind: 'move', x, y}, {kind: 'build', build: 'FARM'}, {kind: 'heal', hp: 80}, {kind: 'hold', mission: 'fortify' | 'sleep' | 'alert'} (last) -- each step runs at most once per turn and the next starts as soon as one completes (a move that arrives starts its build the same turn); it never attacks, declares war or ends the turn, and pauses with a reason when a hostile comes near, the unit is hurt or a step is refused; one open order per unit (replace_id replaces it). orders: the plans with their status; cancel_order / resume_order {order_id}. Not this tool: a one-off move is order(to='unit'); a popup is answer; the board is state. Usable while it is not my turn. Returns {ok: true, ...} with the row written or the rows listed, or {ok: false, err, accepts, example} (an unknown action or a missing argument; nothing is written). A note written on a turn later than the one on screen (a save was loaded) comes back marked later_timeline.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "action": "<action>"
    },
    "name": "notebook"
  }
}

Input Schema

NameRequiredDescriptionDefault
argsNothe action's arguments by name: text / tag / replace_id, note_id, role and purpose with unit_ids / city_ids, assignment_id, unit_id and steps, order_id
actionYesremember | recall | forget | assign | assignments | amend | close | give_order | orders | cancel_order | resume_order
action_idNoa token of my choosing: a retry with the same action_id replays the stored result

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv2.1.0

TDQS

A4.9/5.0
Behavior5/5

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

Annotations declare destructiveHint=true and readOnlyHint=false but say nothing about mechanics; the description supplies them: give_order runs its first step immediately, spends this turn's movement, starts a build, never attacks or ends the turn, and pauses with a reason on hostiles, damage or refusal. It adds the one-open-order-per-unit constraint, the 6-step cap, per-turn step cadence, error shape {ok:false, err, accepts, example} with the guarantee nothing is written, and the later_timeline marker after a save load.

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?

Purpose, exclusions and return shape are front-loaded and every clause carries operational information, but the middle section is a dense run-on with dashes and slashes that is harder to scan than the eleven-action surface warrants. Nothing is redundant, though the format could be more easily parsed.

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?

For an eleven-action, three-parameter tool with no output schema and no nested objects, the description covers purpose, per-action arguments, execution side effects, failure behavior, and the save-load edge case. An agent has enough to call any action correctly on the first attempt.

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?

Schema coverage is already 100%, so this exceeds baseline by documenting each action's argument set inline (remember text/tag/replace_id, assign role+purpose with unit_ids/city_ids, amend, close, order_id) and by spelling out the step grammar {kind:'move'|'build'|'heal'|'hold'} with their fields and the 'last' positional rule. The action_id replay-on-retry contract is also surfaced.

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 opens with a specific metaphor made concrete: persistent free-text notes, assignments, and standing orders that survive a context reset. It then enumerates all eleven actions and explicitly separates itself from siblings ('a one-off move is order(to='unit'); a popup is answer; the board is state'), so an agent can route between notebook, order, answer and state without inspecting schemas.

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?

It states the selection criterion directly ('Use it for what future-me must know; the game itself holds no plan') and gives explicit exclusions naming three sibling tools. It also gives a timing rule ('Usable while it is not my turn') and distinguishes note/assign (inert) from give_order/resume_order (executes now), which is the key branch decision.

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

Deploy Server

Other Tools