> ## Documentation Index
> Fetch the complete documentation index at: https://hired-claude-google-calendar-gmail-integration-bi7nna.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Resume tools
> Seventeen tools for writing documents, checking their length before saving, comparing a tailored variant against its base, publishing them to a link and exporting real PDFs.
Call `get_resume_format` once before your first `create_resume` or `update_resume`. It
returns the exact document shape plus the available templates, fonts and writing guidance,
so what you build validates the first time.
`update_resume` with `data` replaces the **whole** document. Read it with `get_resume`,
modify the JSON you get back, and send all of it. Sending only the section you changed
deletes the rest.
Two dry runs are worth knowing about: `preview_resume_text` renders and estimates length
without saving anything, and `export_resume_pdf` reports the page count measured from the
rendered document rather than estimated.
Tailoring keeps a trail. `duplicate_resume` records which resume the copy came from, so
`compare_resumes` can say exactly what a variant changed — bullets added, dropped and
reworded, sections hidden — and `list_resumes` carries each resume's track record: how many
applications went out with it, how many reached an interview, how many reached an offer.
[The document contract →](/concepts/resumes) · [Publishing and exporting →](/guides/publish-and-export)
The descriptions below are quoted **verbatim** from what the server sends a connected
assistant, which is why they address it rather than you. They are reproduced rather than
rewritten so this page cannot drift from what your assistant actually receives.
### `get_resume_format`
*Get the resume document format*
Returns the exact JSON shape of a resume document plus the available templates, fonts and writing guidance. Call this once before your first create\_resume or update\_resume so the document you build validates.
No arguments.
### `list_resumes`
*List resumes*
All saved resumes with their target role/company, how many applications each is attached to, and publicUrl — the shareable link, or null if that resume isn't published. Each row carries outcomes: how many applications sent with it actually went out, how many reached at least a screen, and how many reached an offer — so this is the tool that answers 'which resume is working?'. Interview and offer counts include applications that got there and later closed, not just where things stand today. Favourites come first, then most recently updated. Pass search to narrow by name, target role or target company when the user names a specific one — 'my Stripe resume' is a search, not a reason to fetch everything.
| Argument | Type | |
| -------- | ------ | ------------------------------------------------------------------------------ |
| `search` | string | Case-insensitive filter on name, target role and target company. Omit for all. |
### `get_resume`
*Get a resume*
Fetch one resume: its settings, its full document JSON, publicUrl — the shareable link, or null if it isn't published — what it was tailored from, the variants tailored off it, and every application it was sent to with the stage each reached. Read this before update\_resume, which replaces the whole document. The applications are what makes 'is this resume working' answerable from one call.
| Argument | Type | |
| --------- | ------- | ----------------------------------------------------------------------------- |
| `id` | string | **required** — Resume id |
| `as_text` | boolean | Also return a flat plain-text rendering, useful for reviewing length and flow |
### `create_resume`
*Create a resume*
Create a resume. Either pass a complete `data` document you have written (call get\_resume\_format first), or pass seedFromMe: true to auto-populate a first draft from Me and then refine it with update\_resume.
| Argument | Type | |
| --------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name` | string | **required** — What to call this resume, e.g. 'Stripe — Staff Engineer' |
| `targetRole` | string | The role being targeted |
| `targetCompany` | string | The company being targeted |
| `template` | string | harvard (default) \| classic \| modern \| compact \| editorial |
| `accent` | string | Accent colour as a hex string. Defaults to '#000000', which is what Harvard expects. |
| `fontFamily` | string | serif (default) \| inter \| mono |
| `fontSize` | number | Base font size in points, 9-12. Default 10. |
| `lineHeight` | number | Line height, 1.15-1.6. Default 1.2. |
| `notes` | string | Private notes about this version — what you tailored and why |
| `showPhoto` | boolean | Render the user's profile photo in the header. Needs a photo set (see set\_profile\_photo) and a template that takes one — harvard never does. |
| `seedFromMe` | boolean | Auto-build a first draft from the knowledge base |
| `baseResumeId` | string | Id of the resume this one was tailored from, if any. Records lineage so compare\_resumes can show what changed. duplicate\_resume sets this automatically — prefer it when the variant starts from an existing document. |
| `data` | object | The full resume document. See get\_resume\_format for the exact shape. Omit if using seedFromMe. |
### `update_resume`
*Update a resume*
Update a resume's settings and/or replace its document. Passing `data` replaces the ENTIRE document, so call get\_resume first, modify the JSON you get back, and send the whole thing.
**Overwrites or deletes.**
| Argument | Type | |
| --------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id` | string | **required** — Resume id |
| `name` | string | New name |
| `targetRole` | string | Target role |
| `targetCompany` | string | Target company |
| `template` | string | harvard \| classic \| modern \| compact \| editorial |
| `accent` | string | Accent colour hex |
| `fontFamily` | string | serif \| inter \| mono |
| `fontSize` | number | Base font size in points |
| `lineHeight` | number | Line height |
| `notes` | string | Private notes |
| `isFavorite` | boolean | Pin this resume to the top |
| `showPhoto` | boolean | Render the user's profile photo in the header. The picture is the one on their profile, so this only switches it on or off for this document. Harvard ignores it by convention. |
| `data` | object | The complete replacement resume document |
### `export_resume_pdf`
*Export a resume as a PDF*
Render a resume to a real PDF on the server and return a download url, plus how many pages it actually came out to. Reach for this when the user wants a FILE to attach to an email or upload to a form — use publish\_resume instead when they want a link. The page count is measured from the rendered document rather than estimated, so it is the reliable way to answer 'does this fit on one page?' before they send it. The url opens in their browser, where they are already signed in; it is not a public link and nobody else can fetch it. If this instance has no headless browser the tool says so and points at the print page, which produces the same document through the browser's own print dialog.
| Argument | Type | |
| -------- | ------ | ------------------------ |
| `id` | string | **required** — Resume id |
### `publish_resume`
*Publish a resume to a public link*
Give a resume a shareable web address. Reach for this whenever the user needs a LINK rather than a file — an application form with a 'portfolio or resume URL' field, a recruiter asking them to send something over, a message where attaching a PDF would be awkward. Returns publicUrl, which is the whole point: hand it straight to the user. Anyone with the link can read the resume without signing in, and the link is the only protection, so it is long and random — it cannot be guessed or found by searching, and the page tells search engines not to index it. The user's private notes on the resume are never shown — but if this resume has showPhoto on, their face is on that page, visible to anyone holding the link. Say so before publishing one, or offer to turn the photo off first. Calling this again while the resume is already published returns the SAME url, so it is safe to repeat. If the resume was previously unpublished, publishing mints a brand new url and the old one stays dead.
| Argument | Type | |
| -------- | ------ | ------------------------ |
| `id` | string | **required** — Resume id |
### `unpublish_resume`
*Withdraw a resume's public link*
Turn off a resume's public link. Reach for this when the user is done with a link, or has sent one somewhere they regret. The page starts returning 'not found' immediately for everyone who has the url. This is PERMANENT for that address: the link is not parked or paused, it is destroyed, and publishing the same resume later produces a different url. Say so before doing it if the user might still need the old link working. Does not touch the resume itself — nothing is deleted.
**Overwrites or deletes.**
| Argument | Type | |
| -------- | ------ | ------------------------ |
| `id` | string | **required** — Resume id |
### `duplicate_resume`
*Duplicate a resume*
Copy an existing resume so you can tailor a variant without losing the original. The usual flow for a new application. The copy records which resume it came from (baseResumeId), so after tailoring, compare\_resumes can show exactly what changed — prefer this over building a tailored document with create\_resume from scratch, which loses that trail unless you pass baseResumeId yourself.
| Argument | Type | |
| -------- | ------ | -------------------------------- |
| `id` | string | **required** — Resume id to copy |
| `name` | string | Name for the copy |
### `tailor_resume_for_application`
*Start a tailored resume for one job*
Copy the base resume, name it for the job, point it at that company and role, and attach it to the application — the four steps this otherwise takes, in one call. Returns the new resume (with its full document, ready to rewrite with update\_resume) and what it was based on. The base is worked out for you: the original document, favourite first, the one that has variants rather than one of the variants. Pass baseId to override that. With nothing on file yet it builds the first draft from what is on file instead of refusing, so a new person asking for a tailored resume gets one. Anything already attached to that application is replaced — the old document is not deleted, it just stops being the one on this job.
| Argument | Type | |
| --------------- | ------ | -------------------------------------------------- |
| `applicationId` | string | **required** — The job this resume is for |
| `baseId` | string | Copy this resume instead of the one picked for you |
| `name` | string | Name for the copy. Defaults to 'Company — Role'. |
### `compare_resumes`
*Compare two resumes*
What changed between two resumes — typically a tailored variant against the base it was duplicated from. Pass just id and it compares against the resume's recorded base (duplicate\_resume sets that automatically); pass base\_id to compare against any other resume. Returns the changed header fields, each section's added and removed bullets and entries, and a one-line summary like '+4 bullets · −2 bullets · summary edited'. A reworded bullet shows as one removed plus one added — old wording beside new, no similarity guessing. Read-only, nothing is written. Reach for this when the user asks what a tailored copy changed, or to review a variant with them before it goes out.
| Argument | Type | |
| --------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `id` | string | **required** — The tailored resume to inspect |
| `base_id` | string | What to compare against. Defaults to the resume's own recorded base; required only when it has none or the user wants a different comparison. |
### `set_resume_base`
*Say what a resume was tailored from*
Record that one resume is a tailored copy of another, so compare\_resumes can compare them. duplicate\_resume sets this for you; this is for documents that already existed, or to re-point one. Pass an empty baseId to unlink. Refuses a loop — two resumes cannot each be the other's base — and refuses to make a resume its own base.
| Argument | Type | |
| -------- | ------ | ------------------------------------------- |
| `id` | string | **required** — The tailored resume |
| `baseId` | string | The resume it came from, or empty to unlink |
### `trace_resume_evidence`
*Which of your own material backs each bullet*
For every experience bullet in a resume, the highlights from Me that stand behind it, best match first, plus a count of the bullets nothing backs. This is derived by comparing text, not recorded when the document was written — so treat a match as 'this claim is in your notes', not as proof of authorship. The unbacked list is the useful half: those are the lines the person cannot expand on from their own material, which is exactly what to walk through before an interview, and what to ask about before writing anything new. Never invent evidence for a bullet that has none.
| Argument | Type | |
| -------- | ------ | ------------------------ |
| `id` | string | **required** — Resume id |
### `delete_resume`
*Delete a resume*
Permanently delete a resume.
**Overwrites or deletes.**
| Argument | Type | |
| -------- | ------ | ------------------------ |
| `id` | string | **required** — Resume id |
### `reorder_resume`
*Move a section, entry or bullet*
Move one piece of a resume to a different position — a section, an entry inside it, or a bullet inside that. Use this instead of update\_resume whenever only the ORDER changes: update\_resume replaces the whole document, so reordering that way means reproducing every word of it and risks dropping content you did not mean to touch. This moves one thing and leaves the rest untouched. Name the thing that moves by giving `section`, plus `entry` if you are moving an entry, plus `bullet` if you are moving a bullet — the deepest one you name is what moves. Each of them takes an id, the name it goes by (a heading, a company or school, the bullet's own words) or its number in the list, so you can pass what the user said. `position` is 1-based: 1 puts it first, and anything past the end puts it last. Returns what moved, from where to where, and the section order that resulted. If nothing matches, the error lists what is actually there — read it and try again rather than falling back to update\_resume.
| Argument | Type | |
| ---------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id` | string | **required** — Resume id |
| `section` | string | **required** — The section: its id, its heading, or its 1-based number |
| `entry` | string | An entry inside that section: its id, the company/school/project it names, or its 1-based number. Give this to move the entry, or to say where a bullet lives. |
| `bullet` | string | A bullet inside that entry: its text (or enough of it to match) or its 1-based number. Give this to move a bullet. |
| `position` | number | **required** — Where it lands, 1-based. 1 is first; past the end is last. |
### `check_resume_fit`
*Check what to cut from a resume*
Reach for this when a resume runs long and the question is what to cut. Returns its bullets ranked longest first — each with the entry it sits under and the path to it — and its sections ranked by how much room they take, so the two obvious levers are in front of you: shorten the worst offenders, or hide a whole section. It RANKS; it does not measure. The page count it reports is the same estimate preview\_resume\_text gives and carries the same limit — it cannot see the type size, leading or margins, and only a browser can. Call export\_resume\_pdf for the real number, then call this to decide what goes. Nothing is written: read it, propose the cuts to the user, and make them with update\_resume once they agree. Cutting a bullet is deleting something true they did, so say which ones you would drop and why rather than dropping them.
| Argument | Type | |
| -------- | ------ | ------------------------ |
| `id` | string | **required** — Resume id |
### `preview_resume_text`
*Preview a resume document as text*
Render a resume document JSON to plain text WITHOUT saving it, and estimate how many lines it will occupy. Use it to check length and flow before committing with create\_resume or update\_resume.
| Argument | Type | |
| -------- | ------ | ------------------------------------------ |
| `data` | object | **required** — A resume document to render |