Skill instructions
blind-candidate-profile2.09 KB
View saved version →
---
name: blind-candidate-profile
description: Make a blind CV or anonymised candidate profile for a client - the candidate's name, contact details and photo removed, in the firm's template, ready for a first submission or fair, bias-free screening. Use when a recruiter asks to "anonymise this CV", "make a blind CV", "remove the candidate's name" or "send an anonymous profile".
---
# Blind candidate profile
Done when: the user has a document in the firm's template with nothing that names or
contacts the candidate, and a list of what was removed.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language; the document follows the template's language.
- Use only facts in the CV. Never invent or replace employers, dates or achievements.
- 1 credit per candidate. Say so if the user did not clearly ask for the document.
- Pass a `request_id` and reuse it on a retry.
- This is a new document, not a correction: `edit_formatted_cv` cannot change a name.
## Steps
1. **Choose the template:** `find_template` with "blind profile" or the template the
user named. A template with a photo slot stays empty: send no photo.
2. **Ask once what to hide** beyond the defaults, if the user has not said: current
employer names, education institutions, age or nationality.
3. **Read the CV yourself** and follow `get_template_schema`. Always remove the name,
email, phone, home address, personal links (LinkedIn included), photo, date of
birth and referees. Use `Candidate A` as the name unless the user gives another
label. Also remove these details where they appear inside the summary or
achievements, and anything else that identifies the person.
4. **Fill:** `fill_template` with the candidates and `candidate_name` `Candidate A`.
If Formatix answers `looks_like_correction`, explain that this is a new document
using credits, and re-send with `confirm_new_document=true` only after a yes.
5. **Report:** the link, what was removed, and what could still identify the person
(a rare job title, a small employer). Ask the user to check it before it goes out.
build-our-template3.56 KB
View saved version →
---
name: build-our-template
description: Turn the firm's own Word, PowerPoint or Excel document (a candidate profile, CV layout, shortlist deck or candidate tracker) into a reusable Formatix template that keeps its fonts, colours, logos and layout, check it with a preview, and change it later in plain language. Use when a recruiter or executive search firm says "make this our template", "use our CV format", "set up our house style", "turn this profile into a template" or "change our template".
---
# Build the firm's template from its own document
Done when: Formatix has saved the template without problems, the user has seen the
preview pages (an invented example candidate) and knows the template's name - or
the user knows exactly what to fix in their file.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language. The template stays in its document's language.
- Use only the file the user attached in this conversation and asked to turn into a
template. Keep its design; never promise styling it does not have.
- Templates Formatix set up for the firm are read-only: when the user wants something
different, build a NEW template; the original is never touched.
- Never put the firm's or a client's template, logo or candidate data in anything
public. Ask the user to remove real candidate details from the file if it holds
any; the preview uses an invented candidate.
## Main path - you design it (no credits)
1. Ask for the file if it is not attached (.docx, .pptx or .xlsx) and a title.
2. Read `get_template_design_guide` and follow it.
3. In your code tool, work on a COPY of the user's file:
- replace only the candidate's details with fields; keep fonts, colours, logos,
spacing and layout;
- Word: the candidate inside `{%p for c in parsed_resume %}` ... `{%p endfor %}`
(each on its own line), fields `{{ c.Field_Name }}`; never the dash forms
`{%-` / `-%}`; lists in one paragraph with line breaks keep bullets tight;
- PowerPoint and Excel: as the design guide says (A_/B_ prefixes for several
candidates per slide).
4. Write the extraction prompt (one line per field; dates, letter case, tone,
pronouns and bullet length follow the user's document and what the user says -
ask when unclear; never invent) and a JSON schema listing every field.
5. `push_designed_template` with the file, `title`, `template_format`, prompt,
schema and a `request_id`. If it returns `problems`, nothing was saved: fix them
and push again.
6. Show the preview pages and compare them with the user's document. Offer to format
a CV with it (format-cvs, `template_type` `cvtobios`).
## Quick path - Formatix builds it (1 credit)
Offer when the user wants it fast or the document is complex:
`create_template_from_file` with the attached file and a title, then
`check_template_status` until `ready`. It is then a `user_template`.
## Change the firm's own template later
`refine_template` with the template's id, one clear instruction ("add a languages
section after education", "make the headings navy") and a `request_id`
(`template_type` `cvtobios` for one saved with `push_designed_template`).
Formatix changes it in place and keeps every earlier version; `get_refine_status`
if it is still working. If it asks a question, pass it on and wait.
## Filling it here
The user's OWN templates can be filled in the conversation: `get_my_template_file`
(24-hour link) plus `get_template_schema`. Templates Formatix set up for the firm
are filled only with `format_cv` or `fill_template`; never offer another way round
credits.
client-shortlist-pack3.84 KB
View saved version →
---
name: client-shortlist-pack
description: Build the client shortlist pack (client submission, candidate slate) for a search - a candidate profile for each shortlisted candidate in the firm's template, a branded shortlist deck, and a cover email draft for the client that the user reviews and sends themselves. Use when a recruiter or executive search consultant says "put together the shortlist for the client", "shortlist pack", "slate for the hiring manager", "client presentation of candidates" or "submit these candidates to the client".
---
# Client shortlist pack
Done when: the user has (1) candidate profiles in the firm's template, (2) a
shortlist deck, and (3) a cover email draft shown in the chat or saved as a draft
in their mail - and nothing has been sent to anyone.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language; documents follow the template's language.
- Use only facts from the CVs and the user's notes. Never invent ratings, fit
scores, compensation, notice periods, readiness or reasons for interest. If the
user gave no rating for a criterion, leave that criterion out.
- Cost: profiles 1 credit per candidate; shortlist deck 0.5 credits. Before starting,
state the total (for example "3 candidates: 3 credits for profiles + 0.5 for the
deck") and wait for a yes unless the user already asked for the whole pack.
- `request_id` on every credit-using call; reuse on retry.
- Confidential search: `brief.confidential = true`, `client_name` (used only to check
the output) and `client_descriptor`. Never write the client's name in documents.
## Steps
1. **Gather.** Role title, client (or confidential descriptor), the shortlisted CVs,
and the user's notes per candidate (fit against must-haves, readiness, notice,
compensation only if the user gives it). Ask once for anything essential that is
missing (the role title, which candidates); do not ask for optional details.
2. **Profiles.** Follow the format-cvs steps: `find_template` (or the template the
user named) -> `get_template_schema` -> one `fill_template` call with all
candidates for a `cvtobios` template, or `format_cv` per CV. Keep each
`record_id`.
3. **Deck.** `render_search_document` with `template_key` `shortlist-deck`,
`brief` (`role`, plus what the user gave) and `candidates`: `name`,
`current_role`, `current_company`, `location`, `summary_points` (2-4 short facts
from the CV), `fit` (`criterion`, `rating` 1-5, only where the user rated it),
`readiness`, `notice`, `compensation`. Use `kit_id` from `list_brand_kits` only
if the user wants the client's brand.
4. **Cover email draft.** Write it yourself in the user's language and the firm's
voice: who is attached, one or two factual lines per candidate, next step the user
proposed (for example interview slots). No claims beyond the user's notes.
- Show the draft in the chat. If the user asks and has Gmail or Outlook connected,
save it as a draft there. **Never send it**, even if asked to "just send it" -
say the user sends it after checking the documents.
- Formatix links expire after an hour: tell the user to download the files and
attach them, not to paste the links into a client email.
5. **CRM / ATS (optional).** If the user asks and has HubSpot, Salesforce, Recruit CRM
or Manatal connected, you may read the job and candidate records to fill gaps the
user confirms, or add a note that the shortlist was prepared. Never change
pipeline stages or send messages from those apps without the user's yes.
6. **Report.** Links to the profiles and the deck (Word/PowerPoint + PDF), the email
draft, and what was left out for lack of facts.
## Repeats and corrections
A correction to a profile is free: fix-a-document. If Formatix answers
`looks_like_correction`, ask before re-sending with `confirm_new_document=true`.
client-submission-email2.64 KB
View saved version →
---
name: client-submission-email
description: Write the candidate submission email (candidate summary, CV cover note, "why this candidate" note) to send a client or hiring manager with a formatted candidate profile - factual highlights against the role, availability and next step - as a draft the user checks and sends themselves. Use when a recruiter says "write the email to submit this candidate", "candidate summary for the client", "cover note for this CV" or "introduce this candidate to the hiring manager".
---
# Client submission email
Done when: the user has a ready-to-edit email draft (subject and body) for the
client, based only on the candidate's CV, the Formatix profile and the user's notes
- shown in the chat or saved as a draft in their mail app. Nothing is sent.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language. Write the email in the language the user asks for
(default: the language they write in).
- Facts only from the CV, the formatted profile and the user's notes. Never invent
achievements, motivations, compensation, notice periods or interview availability.
- This skill uses no credits on its own. If there is no formatted profile yet and the
user wants one attached, follow format-cvs first (1 credit per candidate; say so).
- Never send the email. If asked to send it, say the user sends it after checking it
and the attachment.
## Steps
1. **Source the facts.**
- A profile Formatix made in this conversation: `get_cv_details` with its
`record_id` (read-only, no credits) for the exact details in the document.
- Otherwise the CV the user shared, plus their notes.
2. **Ask once** if missing: the role and client (or confidential descriptor), and the
next step the user wants (call, interview slots, feedback by a date).
3. **Write** in the firm's voice:
- Subject: role and candidate (no client name on a confidential search).
- One opening line: who the candidate is now (title, company type, location).
- 3-5 bullets of evidence against the role's must-haves, each traceable to the CV
or the user's notes.
- Availability, notice and compensation only if the user gave them.
- The next step, and a line that the profile is attached.
4. **Deliver.** Show the draft. If the user asks and has Gmail or Outlook connected,
save it as a draft there (with the recipient only if the user gives it).
Formatix links expire after an hour: tell the user to download the profile and
attach the file, not to paste the link.
Several candidates for one client: offer one email with a short section per
candidate, or client-shortlist-pack for the full pack.
daily-cv-run3.82 KB
View saved version →
---
name: daily-cv-run
description: Set up a recurring ChatGPT scheduled task that formats new CVs or resumes arriving in a mail label or folder into the firm's template every day, with a daily credit cap, no duplicates and a summary of what was done and skipped. Use when a recruiter or delivery team asks to "format new CVs automatically every morning", "process the CVs in my Candidates label each day", "set up a daily CV run" or "automate CV formatting".
---
# Daily CV run (ChatGPT scheduled task)
Done when: the user has approved a scheduled task with a clear source, template,
daily credit cap and schedule - or knows why it cannot be set up on their account
and how to run the same steps by hand.
Explicit instructions from the user take priority over this skill.
## What ChatGPT supports (tell the user plainly)
- Scheduled tasks run one-time or recurring work and can use connected apps such as
Gmail. Active task limits depend on the plan; free accounts run at most once a
day; hourly runs and exact times need a paid plan. Tasks are managed under
**Scheduled**. A task created inside a project cannot read that project's files.
- Event-triggered tasks (for example "when a new email arrives with this label") run
in Work on eligible Plus, Pro, Business, Enterprise and Edu accounts, not on Free
or Go.
- Actions that need the user's approval may pause a task until the user reviews it.
Formatting creates documents and uses credits, so a run may wait for approval.
- If you cannot create the task from this conversation, give the user the task text
below to paste into **Scheduled > New task**.
## Set-up conversation (ask, then confirm)
1. **Source:** the mail label or folder (for example Gmail label "Candidates/To
format") and that the user's mail app is connected in ChatGPT. Formatix itself
only needs the CV text or file.
2. **Template:** `find_template` -> the user picks one; note its id, type and
output format.
3. **Daily limit:** a number from the user (1 credit per candidate). Never assume
one. Ask them to set it at https://platform.formatix.ai/assistant/activity/ too:
Formatix then stops the run itself at that number, and shows what was done.
`get_activity` reads the limit; an assistant cannot change it.
4. **Schedule:** time and time zone, weekdays or every day.
5. **Output:** where results go - the task's summary in ChatGPT (default), or a draft
email to the user, or saved in their cloud storage if that app is connected.
6. Read the task text back and create it only after the user says yes.
## Task text (fill the brackets)
> Every [weekday at 08:00 Europe/London]: find emails in [label] received since the
> previous run with a CV or resume attached (PDF or Word). For each, up to
> [N] candidates in total this run: read the CV and format it into Formatix template
> [name] (id [id], type [type], [docx]) with `format_cv` (`cv_text` = the CV's full
> text as written) or `fill_template` following the template's extraction prompt,
> with a `request_id` of "[message id]", so Formatix never formats the same email
> twice. Never invent details. Skip, and list, any email without a CV, any candidate
> already formatted (Formatix answers already_done or looks_like_correction) - never
> resend with confirm_new_document - and stop at daily_limit_reached, listing what is
> left. Send nothing to candidates or clients. Finish with a summary:
> formatted (name, link), skipped (why), credits used, credits left if known.
## Rules for every run
- Formatix enforces the daily limit and answers `daily_limit_reached`; leftover CVs
wait for the next run and are listed.
- The same `request_id` is never formatted or charged twice (30 days).
- If Formatix reports too few credits, stop and say so in the summary.
- Links last an hour: the summary tells the user to open them promptly, or
`get_formatted_cv` gives fresh ones.
fix-a-document3.07 KB
View saved version →
---
name: fix-a-document
description: Change a candidate profile or formatted CV that Formatix already made - rewrite or shorten the summary, correct a date or job title, add a qualification, reorder roles, or give the candidate a new photo - and get the same document back in the same template at no credit cost. Use when the user says "fix", "correct", "change", "update", "shorten" or "add" something in a CV, profile or shortlist Formatix produced.
---
# Fix a document Formatix made
Done when: the user has the corrected document's new download link and a one-line
summary of what changed - or a clear explanation of why the change needs a new
document and what that costs.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language; keep the document's language unless asked.
- Changes use only facts the user gave or that are in the candidate's CV.
- A correction is ALWAYS `edit_formatted_cv` - never `fill_template` or `format_cv`
again (that is a new document and charges credits again).
- Edits are free, up to 3 per document (a photo counts as one). At most about a fifth
of the text may change. The candidate's name cannot change.
- Studio documents (`template_type` `user_template`) cannot be edited this way.
## Steps
1. **Find the document.** Use the `record_id` from this conversation. If you do not
have it, ask the user which document (Formatix needs the record from the result
that made it).
2. **Read it:** `get_cv_details` with the `record_id`: the details per candidate
(`candidate_index`), whether the photo can change, how many changes are left.
3. **Write the change** yourself in the same shape as the details: send only the
fields that change (a list field is sent whole), for example
`[{"candidate_index": 0, "details": {"Summary": "..."}}]`.
4. **Apply:** `edit_formatted_cv` with `record_id` and `changes`. Each call rebuilds
the document once and uses one of its 3 changes, so put all the corrections the
user asked for into one call.
5. **Photo:** `set_candidate_photo` with the photo the user attached (`photo_file`)
or a public `photo_url`, and `candidate_index`. Only if `get_cv_details` says the
template has a photo slot; otherwise say the template has no place for a photo.
6. **Report:** the new link (works for an hour) and what changed; ask the user to
check it. Earlier versions are kept in Formatix.
## Ask first - never decide alone
- **Rename / different candidate / big rewrite / another template / another
language:** this cannot be an edit. Say so, say it is a new document costing 1
credit per candidate, and wait for a yes. Then use format-cvs (or
translate-candidate-profile / blind-candidate-profile).
- If that new fill is refused with `looks_like_correction` (same candidate, same
template, within the hour), re-send with `confirm_new_document=true` only after the
user confirms the new charge.
- **No changes left:** say so and offer a new document (credits) or editing the
downloaded file by hand.
- Never change the template itself here; template changes are build-our-template.
format-cvs4.61 KB
View saved version →
---
name: format-cvs
description: CV formatting and resume formatting for recruiters. Format a CV or resume into the recruitment firm's own branded template - one candidate or several at once - and return the finished Word, PowerPoint or Excel document (candidate profile, candidate summary, one-page bio, CV in house format, shortlist or tracker). Use when a recruiter or executive search consultant says "format this CV", "put these resumes into our template", "make a candidate profile", "reformat these CVs for the client" or attaches CVs to turn into the firm's format.
---
# Format CVs into the firm's template
Done when: every CV the user gave is in a finished document in the template they
chose, and the user has the download link(s) plus a list of anything that could
not be filled.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language. The document follows the template's language and
extraction prompt; do not translate unless asked (translate-candidate-profile).
- Use only what is in the CV. Never invent employers, dates, titles, degrees,
compensation, notice periods or achievements.
- 1 credit per candidate. If the user clearly asked to format the CVs, go ahead and
state the total; otherwise say the cost first and wait. Short of credits: say so,
credits are managed in Formatix; no talk of prices or plans.
- Pass a `request_id` on every fill and reuse it on a retry.
- Templates Formatix set up for the firm are read-only: follow their extraction
prompt and schema exactly.
## Steps
1. **Collect the CVs.** Attached files (PDF, Word, text) or pasted text. If the user
asks you to take CVs from their email or cloud storage and has that app connected
in ChatGPT, use what it returns; Formatix itself needs only the CV text or file.
2. **Choose the template.** Use the one the user named, else `find_template` with
their words ("one-page executive bio", "candidate profile"). Show at most three
options (name, type, formats); if one clearly fits, say which you will use.
3. **Choose the route.**
- `format_cv` - Formatix reads the CV. One attached CV: `cv_file`. Pasted text:
`cv_text` exactly as given (never summarised or rewritten). Several pasted CVs:
`cv_texts` (up to 10). Best for a straight "format this CV".
- `fill_template` - you read the CVs. Call `get_template_schema`, follow the
extraction prompt for the output format (`docx_`, `pptx_`, `xlsx_`), and send
`candidates` keyed by the schema's field names. Use it for several attached
CVs in one document, when the user wants wording choices (shorter summary,
emphasis on board experience), or a Studio/own template.
- A `cvtobios` template puts up to 10 candidates in one document; a `custom`
template or a Word `user_template` holds one candidate (one call each).
4. **Output format.** `docx` unless the template lists `pptx`/`xlsx` and the user
wants it. Pass `candidate_name` for the file name.
5. **Photos.** Only when the template has a photo slot and the user supplied the
photo. Otherwise leave it out; it can be added later (fix-a-document).
6. **Wait and deliver.** Formatting takes 30 seconds to a few minutes. If you get a
`record_id` without a link, say it is in progress and call `get_formatted_cv`
(pass `template_type` `user_template` for Studio templates). Links work for an
hour; `get_formatted_cv` gives a fresh one.
7. **Report.** Download link(s), one line per candidate, and any detail the CV did
not give (for example no notice period). Ask the user to check before sending.
## If Formatix refuses a repeat
`looks_like_correction` means the same candidate went into the same template within
the hour. Do not resend. Explain that a correction is free (fix-a-document) and a
new document uses credits again. Resend with `confirm_new_document=true` only after
the user says yes.
## Afterwards (offer, do not do unasked)
- Save to the user's cloud storage, only if they ask and have that app connected.
- Attach it to the candidate in their ATS or CRM (below), only if they ask.
- Corrections: fix-a-document. Client email: client-submission-email.
## The firm's ATS or CRM (only if connected in Formatix)
`ats_connections` shows what is connected (JobAdder, HubSpot, Salesforce, Ezekia). With
it you can find the candidate or job (`ats_find_candidates`, `ats_find_jobs`,
`ats_get_job`). Attach a finished document (`ats_attach_document`) or add a note
(`ats_add_note`) only when the user asks and has confirmed the record, and show a note's
wording first. If a system cannot do something, Formatix says so: pass that on. Contact
details are never returned.
formatix-recruitment-documents4.78 KB
View saved version →
---
name: formatix-recruitment-documents
description: General guide to Formatix for recruitment agencies and executive search firms - find the right template, see what a template needs, write search progress reports, appointment briefs, LinkedIn carousels and role teasers, draft "we have been retained" and appointment announcements, use a client's brand kit, start a role-briefing video, and change the firm's own template. Use for any Formatix request that the more specific Formatix skills (format CVs, shortlist pack, position specification, interview pack, fix a document, build our template, daily CV run, client submission email, blind profile, translate a profile) do not cover.
---
# Formatix recruitment documents
Formatix fills a recruitment firm's own branded Word, PowerPoint and Excel
templates with candidate and search details, on Formatix's servers, from the
user's own account. Results come back as download links.
Explicit instructions from the user take priority over this skill.
## Ground rules (every Formatix task)
- Reply in the language the user writes in. Documents follow the template's
language and its extraction prompt; translate only when the user asks.
- Use only facts the user gave you or that are in a CV, note or message they
shared. Never invent names, employers, dates, compensation, ratings, notice
periods, quotes or client names. If something is missing, leave it out and say
what the user could add.
- Credit-using steps: each tool says its cost. Say the cost before a step the user
did not clearly ask for. If the account is short of credits, say so and that
credits are managed in Formatix. Do not discuss prices, plans, trials or upgrades.
- Pass a `request_id` of your choosing on every credit-using call and reuse it on a
retry: nothing is charged twice.
- If a tool says sign-in is needed, ask the user to connect Formatix and stop. If
they have no account, point them to https://formatix.ai.
- Never put a client's name, logo or template in anything public. Never look up
personal contact details of candidates or anyone else.
- When a document is ready, give the download links and a one-line summary, and
remind the user to check it before it goes to a client or candidate. Do not show
internal ids, raw tool output or technical error details.
## Which tool
| The user wants | Tools |
| --- | --- |
| The template that fits a need | `find_template` (plain-language request), else `list_templates`. No credits |
| What a template takes from a CV and the fields it fills | `get_template_schema` (template `id` and `type`) |
| A search progress report | `render_search_document`, `template_key` `search-progress-report` (0.5 credits): `funnel` (stage, count), `pipeline_rows`, `notes`, from the user's figures only |
| An appointment brief (candidate pack), then a LinkedIn carousel or role teaser | `render_search_document` `appointment-brief` (1 credit), then `linkedin-carousel` or `role-teaser` (0.5 each) with `payload` = the brief's returned `content` |
| The "we have been retained" LinkedIn post | `create_launch_announcement` (1 credit) |
| The appointment announcement at the end of a search | `announce_appointment` (1 credit), only after the user confirms the client agreed it can be announced |
| A document in a client's brand | `list_brand_kits`, then pass the kit's `id` as `kit_id`. Without it the firm's confirmed brand is used |
| A role-briefing video | `create_role_briefing_video`, then `get_video_status` |
| A change to the firm's own template | `refine_template` with one clear instruction and a `request_id` (`template_type` `cvtobios` for one saved with `push_designed_template`); `get_refine_status` if still working. Formatix keeps every earlier version |
For CVs, shortlists, position specifications, interview packs, corrections,
new templates, daily runs, submission emails, blind profiles and translations,
follow the matching Formatix skill.
## Briefs
`render_search_document`, `create_launch_announcement` and
`create_role_briefing_video` take a `brief`. `role` is required; add `location`,
`salary`, `reporting_line`, `must_haves`, `organisation_overview`,
`search_reference`, `jd_text` and `consultants` only when the user supplied them.
Confidential search: `brief.confidential = true`, the real client in
`client_name` (used only to check the output) and a neutral `client_descriptor`
such as "a listed European logistics group". Never write the client's name in your
reply, posts or documents.
## Out of scope - decline or redirect
- Posting to LinkedIn or publishing web pages: Formatix drafts, the user posts.
- Deleting templates, documents or data; changing templates Formatix set up for the
firm (read-only): point to https://platform.formatix.ai.
- Buying credits or changing plans.
- Finding personal contact details, scraping LinkedIn or profiling individuals.
interview-pack2.67 KB
View saved version →
---
name: interview-pack
description: Prepare a branded interview pack (interview brief, interviewer guide) for a client interview - fit against the must-haves with evidence from the CV, risk flags to probe, screening questions with what a strong answer sounds like, highlights, and compensation and notice from the consultant's notes. Use when a recruiter or executive search consultant says "interview pack", "prep the client for the interview", "interview guide for the hiring manager" or "questions to ask this candidate".
---
# Interview pack
Done when: the user has the interview pack (Word + PDF) for one candidate and one
role, built only from the CV and their notes, with the gaps listed.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language; write the pack content in the language the user
wants (default: theirs).
- Evidence comes only from the CV and the consultant's notes. Never invent
achievements, ratings, compensation, notice or interview dates. A rating is the
consultant's or yours from stated evidence - say which in the chat.
- Cost: 0.5 credits. Say so if the user did not ask for the pack outright.
- `request_id` on the call; reuse on retry.
## Steps
1. **Gather:** the candidate's CV, the role and its must-haves (from the user, a
position specification or job description), the client, the interview date and
interviewer if known, and the consultant's notes (motivation, concerns,
compensation, notice). If the must-haves are missing, ask for them once.
2. **Draft the payload** for `render_search_document` with `template_key`
`interview-pack` and `brief` `{role}`:
- `candidate_name`, `role_title`, `client` (a descriptor on a confidential
search), `interview_date`, `interviewer` - only if known
- `fit_summary`: two or three sentences
- `fit_points`: one per must-have - `must_have`, `evidence` (from the CV, with
employer and years), `rating` like "4/5"; leave out a must-have with no evidence
and list it as a question instead
- `risk_flags`: `flag`, `why` (gaps in dates, short tenures, missing must-haves)
- `screening_questions`: 5-8, each with `strong_answer`
- `highlights`: `text`, `source` ("CV" or "consultant notes")
- `comp_and_notice`: only what the notes say
3. **Show** the fit points and risk flags briefly if the user wants to review first;
otherwise render.
4. **Render**, then give the links and the list of gaps (for example "no notice
period in the notes"). Remind the user that the pack is for the client's
interviewers and must be checked before it goes out.
Several candidates: one pack per candidate (0.5 credits each); say the total first.
position-specification3.21 KB
View saved version →
---
name: position-specification
description: Turn a new search's intake or briefing-meeting notes, a job description or a call transcript into a branded position specification (role profile, candidate brief, job spec) and, if wanted, a "we have been retained" LinkedIn announcement draft. Use when a recruiter or executive search consultant says "write the position spec", "new search intake", "turn my client meeting notes into a role profile", "draft the job spec for the CFO search" or "announce that we've been retained".
---
# Position specification from intake notes
Done when: the user has a position specification (Word + PDF) built only from their
notes, a list of the gaps to confirm with the client, and - only if asked - the
retained-search announcement drafts. Nothing is posted.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language. Write the brief in the language the user wants the
document in (default: the language of their notes).
- Use only facts in the notes, JD or transcript. Never invent salary, bonus, equity,
reporting lines, team size, location, company facts or the client's name.
- Cost: position specification 1 credit; announcement 1 credit. Say so before a step
the user did not ask for.
- `request_id` on every credit-using call; reuse on retry.
## Steps
1. **Read the material** (pasted notes, attached file, or a meeting transcript or
email the user points to in a connected app such as Gmail, Outlook, OneDrive or
Google Drive - only what they point to).
2. **Build the brief.** `role` (required - ask if missing), and only what the notes
support: `location`, `salary`, `reporting_line`, `must_haves` (short list),
`organisation_overview`, `search_reference`, `jd_text` (the user's JD text as
given), `consultants` (name, title, email, phone only as the user gives them),
`apply_url`. Ask whether the search is confidential if the notes do not say.
3. **Confidential search:** `brief.confidential = true`, `client_name` (used only to
check the output) and `client_descriptor` (for example "a PE-backed UK healthcare
group"). Never write the client's name in your reply or any draft.
4. **Show the brief** in two to six lines and the gaps you left out ("no salary
given"). If the user already asked for the document, go straight on.
5. **Render.** `render_search_document` with `template_key`
`position-specification` and the brief; `kit_id` only if the user wants a client's
brand (`list_brand_kits`). Takes up to a few minutes.
6. **Announcement (only if asked).** `create_launch_announcement` with the same brief:
two post drafts and graphics. Formatix does not post; the user posts after the
client agrees. Never post or publish for them.
7. **Report.** Download links, the gaps to confirm with the client, and the offer to
draft the announcement or a candidate outreach teaser later
(formatix-recruitment-documents: appointment brief, role teaser).
## Optional connected apps
If the user asks and has a CRM or ATS connected (HubSpot, Salesforce, Recruit CRM,
Manatal), you may read the job record to fill gaps the user confirms, or attach a
note that the specification was drafted. Do not create or change records unasked.
setup1.85 KB
View saved version →
---
name: setup
description: Get a recruiter or search firm started with Formatix after installing the plugin - check the account, find or build the firm's CV template, check the brand, see any connected ATS or CRM, and format a first CV. Use when the user says "set up Formatix", "get started" or "how do I start", or right after the plugin is installed.
---
# Set up Formatix
Done when: the user knows which template they will use and what to do next, or knows the
one thing they still need to do. Keep it short: a few questions, no lecture.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language.
- Nothing here uses credits, and nothing is created without the user's yes.
- If a tool says sign-in is needed, ask the user to connect Formatix and stop. If they have
no account, point them to https://formatix.ai.
- Do not discuss prices, plans or trials.
## Steps
1. **Templates:** `list_templates`. Tell the user what they have in one or two lines.
- They have one that fits: note it and go on.
- They have none: ask for a document they already send clients (Word, PowerPoint or
Excel) and follow build-our-template.
2. **Brand:** `list_brand_kits`. Mention the firm's brand and any client brands. If there are
none, say the firm's own templates already carry its design.
3. **ATS or CRM:** `ats_connections`. If something is connected, name it and say what can be
done from the chat (format-cvs lists this). If not, say it can be connected on the
Integrations page in Formatix if they use JobAdder, HubSpot, Salesforce or Ezekia.
4. **Automation, only if they ask for it:** get_activity shows the daily limit, and
daily-cv-run sets up a recurring run.
5. **First document:** offer to format one CV now (format-cvs). Stop here if they say no, and
give them two example requests in their own terms.
translate-candidate-profile1.98 KB
View saved version →
---
name: translate-candidate-profile
description: Translate a candidate profile or CV into another language in the firm's template, keeping the layout - for example a German Lebenslauf from an English CV, or a French candidate profile for a client in Paris. Use when a recruiter asks to "translate this CV", "make this profile in German" or "send the client a French version".
---
# Translate a candidate profile
Done when: the user has a new document in the requested language, in the firm's
template, with names, employers, dates and figures unchanged.
Explicit instructions from the user take priority over this skill.
## Ground rules
- Reply in the user's language.
- Translate, never improve: add no facts. Keep names, employers, product names, dates
and figures as they are. Keep qualifications in their original form when there is no
exact equivalent, and say which ones.
- 1 credit per candidate: this is a new document. Say so if the user did not clearly
ask for it. Pass a `request_id` and reuse it on a retry.
- The template's own headings stay in the template's language. If they should change
too, say so first and look for a template in that language with `find_template`.
## Steps
1. **Get the source:** the CV the user shared, or the details of a document Formatix
made (`get_cv_details` with its `record_id`; no credits).
2. **Choose the template:** the one the user named, else `find_template`, preferring
one in the target language. Read `get_template_schema`.
3. **Translate** each field into the target language, using the terms a recruiter in
that country would use. Follow the template's extraction prompt for everything else.
4. **Fill:** `fill_template`. If Formatix answers `looks_like_correction`, explain that
this is a new document using credits, and re-send with `confirm_new_document=true`
only after a yes.
5. **Report:** the link, one line on what was left untranslated and why, and a reminder
to have a fluent speaker check it before it goes to a client.
