Skip to main content
Glama

Tailor Resume Session

tailor_session
Destructive

Generate a job-specific application by applying saved resolutions and edit operations, then score and render the tailored resume as a PDF.

Instructions

Run the tailor pipeline for a session: saved resolutions -> edit ops -> the job's tailored application, scored and rendered.

Three ways to produce the edits:
- ops omitted: Maestro's AI writes them, only when the user's writer setting
  (get_setup_status) is Maestro's AI; otherwise refused (409).
- ops: the caller's own typed edit ops, the shapes edit_application takes
  (its ops schema lists each kind), carrying only the changed fields; no
  model call.
- no_new_text=True: no new wording and no model call, under either setting.
The ops and no_new_text parameters say which saved answers the server
applies; answers_left_to_ops lists the ones that need wording.

Caller-supplied ops are applied as authored: the server validates structure
only, so nothing gates fabricated skills, experience, metrics, or dates. A
skill the candidate cannot evidence goes only in the skills list
(add_skill_item), not in a bullet; the compare view audits any edit beyond
the saved resolutions. Resume text is implied first person: an edited line
in I/he/she voice or naming the owner is a 400 naming the lines.

Optional user_prompt adds free-form tailoring guidance. Writes the job's ONE
application from the base plus the edits: it rebuilds the draft (version
history keeps the old draft) and renders its PDF; pdf_ready is false when
that render failed. compare (before/after match score deltas) may be null
with compare_error set: the tailor still succeeded. unbacked_skills names
missing skills this tailor put on the resume that career history does not
back. kb_writeback_skips derives from each user_input resolution's STORED
placement_target from resolve_gaps, not from the ops, so ops that disagree
with the stored target produce a spurious wrong_section skip. `next` (null
when off or unavailable): render_pdf if pdf_ready is false, else apply
readiness; no_new_text's answers left come first.

Input Schema

NameRequiredDescriptionDefault
opsNoTyped edit ops, the shapes edit_application's ops parameter lists; omitted (and no_new_text false), Maestro's AI writes them when the user's writer setting is Maestro's AI. With ops the server itself applies only the saved enable_entry and port_kb_point answers: user_input and attach_project answers reach the resume only through these ops, and answers_left_to_ops lists them. On every path a saved add_keyword whose word (its wording, else the gap's jd_skill) is not on the result is added to the skills list, in the category it chose, else Additional Skills, never as a bullet; keywords_added lists those words.
no_new_textNoTrue: Maestro writes no new wording and calls no model, whichever writer setting the user chose. It applies only the saved answers that need none: enable_entry, port_kb_point (an approved career-history bullet) and add_keyword into the skills list (keywords_added lists the words). An add_keyword placed anywhere else needs a rewritten line: its word lands in the skills list when the resume lacks it, and otherwise the answer is listed in answers_left_to_ops beside the user_input and attach_project answers; nothing listed there reaches the resume. With non-empty ops it is a 422; when nothing can be applied without new wording it is a 400 that says so.
user_promptNo
tailoring_session_idYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changedv0.12.0
    • addedInput schema / properties / no_new_text
      Added value: +{
      +  "default": false,
      +  "description": "True: Maestro writes no new wording and calls no model, whichever writer setting the user chose. It applies only the saved answers that need none: enable_entry, port_kb_point (an approved career-history bullet) and add_keyword into the skills list (keywords_added lists the words). An add_keyword placed anywhere else needs a rewritten line: its word lands in the skills list when the resume lacks it, and otherwise the answer is listed in answers_left_to_ops beside the user_input and attach_project answers; nothing listed there reaches the resume. With non-empty ops it is a 422; when nothing can be applied without new wording it is a 400 that says so.",
      +  "title": "No New Text",
      +  "type": "boolean"
      +}
    • addedInput schema / properties / ops / description
      Added value: +"Typed edit ops, the shapes edit_application's ops parameter lists; omitted (and no_new_text false), Maestro's AI writes them when the user's writer setting is Maestro's AI. With ops the server itself applies only the saved enable_entry and port_kb_point answers: user_input and attach_project answers reach the resume only through these ops, and answers_left_to_ops lists them. On every path a saved add_keyword whose word (its wording, else the gap's jd_skill) is not on the result is added to the skills list, in the category it chose, else Additional Skills, never as a bullet; keywords_added lists those words."
  2. First observedv0.11.1

TDQS

A4.2/5.0
Behavior5/5

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

Far beyond the annotations (destructive, non-idempotent, open-world), the description discloses that it rebuilds the draft while version history preserves the old one, renders the PDF and can return pdf_ready=false, and that compare may be null with compare_error set while the tailor still succeeded. It also exposes non-obvious contract details: structure-only validation of caller ops, the voice rule producing a 400 naming offending lines, the unbacked_skills audit, and the kb_writeback_skips quirk tied to resolve_gaps' stored placement_target.

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?

Purpose is front-loaded well, but the body is a dense sprawl of run-on sentences and nested parentheticals, mixing core routing rules with niche diagnostics like spurious wrong_section skips. Several details (kb_writeback_skips derivation, next ordering) are genuinely useful but buried where an agent skimming for 'when do I use this' will miss them.

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?

With no output schema, the description carries the full return-value burden and does so: pdf_ready, compare/compare_error, unbacked_skills, kb_writeback_skips, answers_left_to_ops, keywords_added, and the `next` fallback chain are all explained. For a destructive, non-idempotent pipeline tool with four parameters, an agent has everything needed to call it and interpret the result.

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 50%, and the description compensates: user_prompt is explained as free-form tailoring guidance, and ops/no_new_text gain cross-parameter semantics the schema can't express (ops are applied as authored with no fabrication gate; no_new_text conflicts with non-empty ops at 422; which saved answer kinds flow through ops vs. server application). tailoring_session_id is left unexplained, but its meaning is evident from the tool name.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence states a specific verb, resource, and outcome: run the tailor pipeline for a session, producing the job's scored and rendered application from saved resolutions plus edit ops. It distinguishes itself functionally from edit_application by naming that tool's ops schema as the source of op shapes, but it never frames a clean contrast ('use this instead of edit_application when...'), so differentiation is by reference rather than explicit statement.

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?

The three-way breakdown (ops omitted -> Maestro AI writes when get_setup_status says so, else 409; caller ops -> no model call; no_new_text -> no wording, no model call) gives explicit selection criteria and failure modes, including ops + no_new_text = 422. What's missing is guidance on when to pick this tool over sibling paths such as edit_application or edit_base_resume rather than how to pick a mode within it.

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