Skip to main content
Glama

Update a job

job_update
Destructive

Change a job at the revision you read (a stale one refuses CONFLICT with currentRevision; read it again with job_get): its name, purpose or description (null clears either), agents (the set you send replaces the old one; adjust your own role this way), definitions (the set you send replaces the whole set: send every definition to keep; a set sent as it is changes nothing, and a step's lastCheck and health, as job_get reads them, are ignored), or archived (true archives it: it leaves workspace_load and takes no new tasks, and tasks keep its name; false restores it).

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": {
      "id": "<id>",
      "expectedRevision": "<expectedRevision>"
    },
    "name": "job_update"
  }
}

Input Schema

NameRequiredDescriptionDefault
idYesThe job, by its id (job_create returns it; workspace_load lists your jobs and the others by id).
whyNoRequired for workspace items: one sentence on what the person is trying to accomplish, in their terms, not a description of this edit. Every workspace write takes one; sessions and summaries record themselves from it. At most 300 characters.
nameNoThe job's name, unique in the workspace (founder-posts, inbox-triage): lowercase letters, digits, - and _, starting with a letter or a digit, at most 64 characters.
agentsNoThe job's agents, replacing the ones it has (send [] for none), at most 20: { agent, role? }.
purposeNoOne line on what the job is for, at most 280 characters ("The founder's notes become posts on X and LinkedIn"): shown under its name wherever jobs are listed, so a reader can tell which job does what. Empty is none. null clears it.
archivedNotrue archives the job: it leaves workspace_load and takes no new tasks, and tasks keep its name. false restores it.
definitionsNoThe job's task definitions, at most 5, in order: each says what a task of the job is (its types), how to create one (instructions) and the steps it goes through: { name, types, instructions?, steps }. The job's purpose, description and definitions take at most 30000 bytes as JSON. The set you send replaces the whole set the job has: send every definition to keep (job_get reads them), [] for none.
descriptionNoWhat the job is and how it is done, in markdown, at most 8000 characters: the standing brief its agents read. The job's purpose, description and definitions share 30000 bytes as JSON. null clears it.
expectedRevisionYesThe job's revision as you read it (job_get, job_create); a stale one is CONFLICT with currentRevision.

Output Schema

NameRequiredDescriptionDefault
jobYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Added

TDQS

A4.3/5.0
Behavior4/5

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

Annotations already declare destructiveHint=true and non-idempotent, and the description earns its keep by disclosing the concrete destruction surface: agents and definitions are wholesale-replace sets, archived=true removes the job from workspace_load and blocks new tasks, and read-only fields (lastCheck, health) are silently ignored. It stops short of saying that omitted optional fields leave the job untouched, which is the main ambiguity an agent faces.

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?

Front-loads the most important constraint (stale revision refuses with CONFLICT) and wastes no words, but it is a single ~90-word sentence with heavily nested parentheses covering five distinct mutation targets. Information density is high; scanability is poor, and the reader must parse the parenthetical tree to find the field-level rules.

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 9-parameter destructive mutation with an output schema and full schema coverage, the description supplies the concurrency protocol, the replace-vs-merge semantics for both collection fields, the archive lifecycle, and the ignored read-only fields. The remaining gap is whether unspecified optional fields are preserved, which matters for a partial-update tool.

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 the baseline is 3, but the description adds real semantics beyond it: null clears name/purpose/description, the agents array replaces rather than merges (and is how you adjust your own role), definitions must be sent in full to be kept, and a verbatim resend is a no-op. These are behavioral consequences the schema text alone does not make operationally obvious.

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?

States a specific verb and resource ('Change a job at the revision you read') and immediately names the sibling used for the prerequisite read ('read it again with job_get'), so it is distinguishable from job_get and job_create without opening any schema. It also enumerates exactly which parts of the job can be changed.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives a clear conditional: you must hold the revision you read, and on CONFLICT you must re-read with job_get rather than retry blindly. It does not contrast with adjacent write tools (task_update, workspace_update, job_create) or say when to prefer reaching definitions via some other path, so it stops short of explicit alternatives.

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.