clawhub

Liber8 Career Agent

Item: Liber8 Career Agent
Rating: 8.2
Author: Implexa

Manage recurring personalized job searches, analyze CVs, generate tailored application packs, and deliver ranked opportunity pipelines with DOCX attachments.

copies: implexa run clawhub/liber8

view source

installs

stars

karma

SkillRank score ↗

8.2/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-05-26

liber8 automates personalized job discovery and application-pack generation through a local workspace pipeline, consuming user profile, resume, and preferred sources to produce ranked opportunity shortlists with markdown and docx variants.

structure

9.0

trigger phrases

8.0

procedure

9.0

edge cases

7.0

documentation

8.0

strengths

view original SKILL.md from clawhubclick to expand

---
name: liber8
description: Role discovery and application-pack workflow for an individual job seeker. Use when setting up or operating Liber8: onboard a user, collect a resume and preferences, bootstrap the Liber8 workspace, run the bundled pipeline, review ranked opportunities, generate application-pack drafts, and optionally create a recurring run. Do not assume a fixed seniority, board bias, provider, or delivery endpoint unless the user explicitly chooses one.
---

# Liber8

Liber8 is a recurring opportunity-discovery workflow for one person.
The skill now includes its own runnable path:
- `scripts/bootstrap_liber8.py` to create the user-local workspace
- `scripts/liber8_pipeline.py` to run deterministic discovery, filtering, dedupe, and pack generation
- `scripts/render_recurring_prompt.py` to generate the exact prompt used by a Liber8 recurring run
- templates in `assets/templates/` for profile, resume, and recurring-run notes

## Credentials and environment model
Liber8 has no skill-specific API keys.
It should use capabilities already available in the user's OpenClaw environment.

Expected environment:
- OpenClaw web/search/fetch access for discovery and validation
- an AI model if the host wants richer drafting later
- an optional delivery channel if the host wants outbound summaries or attachments

If delivery or drafting capability is not configured, Liber8 should still work locally.
Do not ask the user to paste secrets into prompts or store credentials inside the skill.

## Scope and safety boundaries
Keep Liber8 scoped to the user-approved Liber8 workspace and its own recurring run.
In scope:
- the Liber8 skill folder
- the bundled Liber8 scripts
- the user-local Liber8 config/state/output paths created during bootstrap
- the specific recurring run created for Liber8
- user-provided role URLs, employer sites, and source lists relevant to discovery

Out of scope unless the user explicitly asks:
- unrelated repos or scheduler entries
- shell startup files or OS service config
- cookies, browser stores, login/session secrets
- broad crawling beyond role-relevant pages
- writes outside the Liber8 workspace/config paths

## Install and first-run checklist
1. Bootstrap a local Liber8 workspace by running `scripts/bootstrap_liber8.py`.
2. Fill in the generated profile JSON and resume text file.
3. Run `scripts/liber8_pipeline.py` manually once.
4. Inspect `summary.txt`, `manifest.json`, and generated pack files.
5. Only then enable recurring automation if the user wants it.

## Real execution path
Use this path instead of relying on an external proof-of-concept script:
1. Run `scripts/bootstrap_liber8.py --workspace <workspace> --skill-root <skill-root>` once.
2. Edit the generated profile at `liber8/config/profiles/<name>.json`.
3. Edit the generated resume at `liber8/config/resumes/<name>.txt`.
4. Run:
`python <skill-root>/scripts/liber8_pipeline.py --profile <profile-json> --resume <resume-txt> --state-dir <workspace>/liber8/state --output-dir <workspace>/liber8/output`
5. Read:
- `liber8/output/summary.txt`
- `liber8/output/manifest.json`
- generated markdown pack files in `liber8/output/`
6. If the user wants automation, generate the recurring-run prompt with:
`python <skill-root>/scripts/render_recurring_prompt.py --skill-root <skill-root> --workspace <workspace> --profile <profile-json> --resume <resume-txt> --state-dir <workspace>/liber8/state --output-dir <workspace>/liber8/output`
7. Create or update one Liber8-specific recurring run using that generated prompt.

## Onboarding flow
When first setting up Liber8 for a user, make onboarding conversational and stepwise.
Do not dump a large questionnaire all at once.
Ask one question at a time, pause for the answer, then ask the next most relevant question.

### Resume intake
Start by helping the user provide a resume/CV in whichever form is easiest for them:
- file upload
- a file placed in a known local directory
- a URL to the resume/CV
- pasted text

For the local-directory path, do not ask the user to invent a file path.
Instead, tell them to use the fixed Liber8 intake folder:
- `liber8/inbox/`

This inbox can be used for:
- CVs / resumes
- job descriptions
- saved role adverts or exported role documents the user wants Liber8 to assess or apply against

Then ask them for the filename, or let them simply say "done" if there is only one obvious relevant file there.

If the user has not provided a resume yet, do not continue into deep search configuration. First resolve resume intake.
If needed, help them populate the resume template incrementally.

### Conversational sequence
After resume intake, gather the rest in small steps rather than one big form. A good order is:
1. target role families and exclusions
2. target seniority / level range
3. geography, commute, and remote/hybrid/onsite preferences
4. sectors to prioritise or avoid
5. target employers and employers to avoid
6. delivery preference: local-only or configured channel delivery
7. if using delivery, collect channel, target, whether to attach packs, and preferred formats
8. whether they want recurring automation after first-run validation

Write the answers into the generated profile file as you go.
Then:
9. extract employer names from the user's resume
10. infer likely competitors of those employers
11. run `scripts/search_source_candidates.py` to discover candidate source sites from target employers, resume employers, and likely competitors
12. show those candidate sources to the user and let them exclude any they do not want, keep the ones they do want, and add any extra sources manually
13. add the selected sources to the profile/source registry
14. run a manual first pass
15. review the shortlist with the user before enabling automation
16. ask for feedback on the shortlist: which roles felt promising, which felt off-target, which employers/titles/locations/themes should be favoured or avoided
17. write that feedback into the profile so future runs sharpen ranking and source selection

## Search design
Liber8 should search in layers.
- start from the candidate's configured role families, sectors, location, work mode, target employers, preferred sources, and accumulated feedback
- during onboarding, search for candidate source sites the user can choose from
- use selected source URLs and employer careers pages as the primary discovery path
- use broader search results only as fallback discovery inputs, not as final validation on their own
- dedupe previously surfaced roles through the local state ledger
- continuously sharpen ranking using explicit user reactions to previous shortlists

If a user shares a role URL:
1. inspect it
2. decide if it is live and relevant
3. generate a pack if relevant
4. add the domain/source only if it looks reusable

If a user drops a JD / role file into `liber8/inbox/`:
1. read it
2. assess whether it is relevant to the user's current ambitions
3. generate or refine an application pack against it if useful
4. ask whether this role or employer should influence future search preferences

If a user shares a target employer:
1. add it to the profile
2. use it in future discovery runs
3. consider competitor employers and their careers sites during source discovery

After each meaningful shortlist review, ask brief feedback questions such as:
- Which 1-3 roles were closest to what you want?
- Which ones were clearly wrong, and why?
- Are we under-targeting or over-targeting seniority?
- Which employers, functions, sectors, or geographies should be favoured or avoided next time?

Use the answers to update the feedback section of the profile rather than keeping them as loose chat context.

## Output contract
A successful Liber8 run should produce local files even with no outbound delivery configured:
- `summary.txt` -> concise shortlist
- `manifest.json` -> structured run output
- one application-pack draft per shortlisted role in Markdown
- plain-text and DOCX variants where generated

If the user configures delivery and the chosen channel supports attachments, Liber8 should prefer attaching generated pack files such as DOCX and Markdown.
If the chosen channel does not support attachments, send the shortlist and include local file paths instead.

## Drafting rule
If the host environment has a suitable AI model, Liber8 may use it for stronger cover-letter or CV refinement.
If not, the bundled pipeline should still produce deterministic local draft packs.
Do not require a model-specific credential owned by the skill.
Do not invent facts.

## Automation rule
Only create recurring automation when the user explicitly asks for it.
That automation should call the bundled pipeline script with the user's profile/resume/state/output paths.
Use `scripts/render_recurring_prompt.py` to generate the exact agent-turn text for the recurring run so the automation path stays consistent with the manual path.
Default recurring behavior to local-only reporting unless the user has explicitly configured a delivery destination.
Do not inspect or modify unrelated scheduler entries.
Prefer sandbox or test-workspace validation before enabling recurring runs.

## Files bundled with this skill
- `scripts/bootstrap_liber8.py`
- `scripts/liber8_pipeline.py`
- `scripts/render_recurring_prompt.py`
- `scripts/search_source_candidates.py`
- `assets/templates/profile.template.json`
- `assets/templates/resume.template.txt`
- `assets/templates/source-registry.template.json`
- `assets/templates/recurring-run-notes.txt`
- `assets/examples/sample-profile.json`
- `assets/examples/sample-resume.txt`
- `references/liber8-setup-and-ops.md`

## Example prompts
- Set up Liber8 for me.
- Bootstrap Liber8 in this workspace and show me which files to edit.
- Use Liber8 to analyse my resume and build a first search profile.
- Run Liber8 with my current profile.
- Add these employers to Liber8: <list>
- Update Liber8 to prioritise product roles in London with hybrid work.
- Create a recurring Liber8 run every weekday at 07:30 after we validate the manual run.

related skills

semantically similar in the cross-vendor index

clawhub

65% match

Skill Forge

Detect repeated capability gaps, convert recurring user needs into candidate skills, scaffold new OpenClaw-compatible skills, and validate them before instal...

by @clawhub

don't have the plugin yet? install it then click "run inline in claude" again.

added explicit inputs section documenting environment, optional configs, and bundled scripts; restructured procedure into five numbered phases with clear input/output contracts for each step; extracted seven decision points covering missing resume, unavailable delivery, empty results, profile updates, attachment failures, state corruption, and network timeouts; formalized output contract with file paths and format guarantees; defined outcome signal as verifiable user-facing milestones.

Liber8

intent

Liber8 is a recurring opportunity-discovery workflow for a single job seeker. use it to onboard a user, collect their resume and role preferences, bootstrap a local workspace, run a deterministic search and filtering pipeline, review ranked opportunities, generate application-pack drafts, and optionally schedule recurring automation. do not assume fixed seniority, board bias, provider, or delivery endpoint unless the user explicitly chooses one. the skill works entirely within a local workspace with no skill-specific API keys, leveraging only capabilities already available in the user's OpenClaw environment.

inputs

required:

user resume or CV in any form: file upload, local directory placement (liber8/inbox/), URL, or pasted text
target role families and seniority range (gathered conversationally, one question at a time)
geography, commute mode, and work-mode preference (remote, hybrid, onsite)

optional:

target employers, competitors, and employers to avoid
sector or function inclusions and exclusions
delivery channel config (local-only, email, Slack, or other configured OpenClaw channel)
user feedback from previous shortlists to refine ranking and source selection

environment:

OpenClaw web/search/fetch access for discovery, validation, and candidate-source discovery
AI model capability (optional, for richer cover-letter or CV refinement; not required)
delivery channel integration (optional; skill works local-only if not configured)
Python 3.8+ for bundled scripts

no credentials required:

Liber8 has no skill-specific API keys
do not ask users to paste secrets into prompts
do not store credentials inside the skill

bundled scripts and templates:

scripts/bootstrap_liber8.py: create the user-local workspace
scripts/liber8_pipeline.py: run discovery, filtering, deduplication, and pack generation
scripts/render_recurring_prompt.py: generate exact prompt for recurring automation
scripts/search_source_candidates.py: discover candidate source sites from target employers and resume history
assets/templates/profile.template.json: profile schema
assets/templates/resume.template.txt: resume template
assets/templates/source-registry.template.json: source registry schema
assets/templates/recurring-run-notes.txt: notes for recurring runs
assets/examples/sample-profile.json, sample-resume.txt: reference examples

procedure

phase 1: bootstrap workspace

input: user requests Liber8 setup or first run
- run scripts/bootstrap_liber8.py --workspace <workspace> --skill-root <skill-root> once
- output: new directory tree at <workspace>/liber8/ with config/, state/, output/, and inbox/ subdirectories, plus generated profile and resume templates
input: empty profile and resume files created in step 1
- direct user to place resume in liber8/inbox/ or upload directly
- output: resume file stored at liber8/config/resumes/<name>.txt

phase 2: gather preferences conversationally

input: confirmed resume location and basic user availability
- ask for target role families (e.g., "product manager", "staff engineer", "growth analyst")
- output: user provides 2-4 role family names; write to liber8/config/profiles/<name>.json under targetRoles field
input: target role families confirmed
- ask for seniority or level range (e.g., "mid to senior", "IC4-IC5", "3-7 years experience")
- output: seniority range stored in profile under seniorityRange field
input: seniority confirmed
- ask for geography, commute distance or mode (remote-first, hybrid, onsite), and any location must-haves or must-avoids
- output: location and work-mode prefs stored in profile under geography, workMode, commute fields
input: location and work mode confirmed
- ask for sector or function priorities and exclusions (e.g., "prioritise fintech and climate", "avoid gaming and ad-tech")
- output: sector/function prefs stored in profile under sectors and excludedSectors fields
input: sector preferences confirmed
- ask for target employers (dream-list or places the user knows well) and any employers to avoid
- output: employer list stored in profile under targetEmployers and avoidEmployers fields
input: target employers listed
- extract employer names and domains from the user's resume
- run scripts/search_source_candidates.py --target-employers <list> --resume-employers <extracted> --skill-root <skill-root> to discover candidate source sites (e.g., LinkedIn, Indeed, company careers pages, niche boards)
- output: candidate source URLs and domains discovered; present them to user for review
input: candidate sources presented to user
- ask user to confirm, exclude, or add sources manually
- output: selected sources written to liber8/config/profiles/<name>.json under sources field
input: sources confirmed
- ask for delivery preference: local-only or configure outbound delivery (email, Slack, webhook, etc.)
- output: delivery config stored in profile under delivery field (or "local" if local-only)
input: delivery preference confirmed
- if outbound delivery chosen, collect channel name, target address/webhook, whether to attach packs, and preferred formats (Markdown, DOCX, plain text)
- output: attachment and format prefs stored under delivery.attachments and delivery.formats fields

phase 3: first manual run and validation

input: profile and resume fully populated, sources selected, delivery configured
- run python <skill-root>/scripts/liber8_pipeline.py --profile <profile-json> --resume <resume-txt> --state-dir <workspace>/liber8/state --output-dir <workspace>/liber8/output
- output: pipeline generates summary.txt, manifest.json, and one Markdown/DOCX pack per shortlisted role
input: first run complete
- read liber8/output/summary.txt (concise shortlist) and liber8/output/manifest.json (structured run data)
- present shortlist to user with role titles, employers, locations, and links
- output: user reviews shortlist
input: user has reviewed shortlist
- ask for feedback: which 1-3 roles felt closest, which were clearly wrong and why, seniority mismatches, sector/location/employer preferences to adjust
- output: feedback written to profile under feedback field for future ranking refinement

phase 4: recurring automation (optional)

input: user explicitly requests recurring automation after validating first run
- run python <skill-root>/scripts/render_recurring_prompt.py --skill-root <skill-root> --workspace <workspace> --profile <profile-json> --resume <resume-txt> --state-dir <workspace>/liber8/state --output-dir <workspace>/liber8/output
- output: exact agent-turn prompt text for recurring run
input: recurring prompt generated
- create or update one Liber8-specific recurring run using the generated prompt
- set frequency (e.g., daily, weekday, weekly) based on user request
- output: recurring run configured and enabled in host scheduler

ad-hoc flows

input: user shares a role URL mid-cycle
- inspect the URL; determine if it is live and relevant to the user's profile
- if relevant, generate an application pack against the role
- if the source domain is new and reusable, ask whether to add it to the profile source list
- output: application pack file(s); optional profile update
input: user drops a job description or role file into liber8/inbox/
- read the file; assess relevance to the user's current profile
- generate or refine an application pack if useful
- ask whether this role or employer should influence future search preferences
- output: application pack(s); optional feedback and profile update
input: user requests profile or source list changes mid-cycle
- edit liber8/config/profiles/<name>.json or liber8/config/source-registry.json with user input
- do not re-run the full pipeline unless explicitly asked
- output: updated profile/source list; confirm changes with user

decision points

resume not yet provided:

if user has not provided a resume, do not progress to deep search configuration
instead, pause and resolve resume intake first
if needed, help the user populate the resume template incrementally by asking for key sections (experience, education, skills) one at a time

delivery capability not available:

if the host environment has no configured delivery channel or delivery is not requested, liber8 still works and produces local files only
do not fail the workflow; local-only operation is a valid outcome
do not ask the user to paste secrets or configure credentials inside the skill

no AI model available for drafting:

if the host has no suitable AI model, the bundled pipeline produces deterministic local draft packs without loss of core functionality
do not require a model-specific credential owned by the skill
do not invent facts in application packs

source discovery fails or returns empty:

if search_source_candidates.py returns no candidate sources, fall back to asking the user to provide sources manually (e.g., "where do you usually find job boards?")
allow the user to proceed with a minimal source list

first-run shortlist is empty or off-target:

if the pipeline returns no roles or roles that clearly miss the mark, review the profile settings with the user
ask whether role families, seniority, location, or sector filters are too narrow
loosen one filter at a time and re-run before enabling automation

user requests profile updates after recurring runs have started:

allow in-place profile updates without recreating the recurring run
the next scheduled run will pick up the new profile state
write changes to the profile JSON file directly

attachment generation fails due to format or permissions:

if DOCX generation fails but Markdown succeeds, deliver Markdown only and note the issue to the user
do not block delivery on attachment format failures
fall back to text-only or local file paths in the delivery message

deduplication ledger stale or corrupted:

if the state ledger in liber8/state/ becomes corrupted or unreadable, delete it and allow the next run to rebuild from scratch
warn the user that some previously seen roles may reappear in the next shortlist

recurring run timeout or network failure:

if a scheduled run fails due to network timeout or temporary service unavailability, log the failure and allow the next scheduled run to proceed
do not retry within the same run window; rely on the next scheduled window
deliver a summary of the last successful run if the latest attempt failed

output contract

a successful liber8 run produces the following local files, whether or not delivery is configured:

liber8/output/summary.txt: concise shortlist in plain text, one role per line with title, employer, location, and URL
liber8/output/manifest.json: structured run metadata including timestamp, profile version, sources searched, deduplication stats, and role rank scores
liber8/output/<role-slug>.md: one application-pack draft per shortlisted role in Markdown format, including role description, match score, suggested cover-letter opening, and CV callout recommendations
liber8/output/<role-slug>.docx: DOCX variant of application pack where generation succeeds (optional if DOCX library unavailable)

if the user configures delivery and the chosen channel supports attachments, liber8 prefers attaching generated pack files (DOCX and/or Markdown). if the chosen channel does not support attachments, liber8 delivers the shortlist summary and includes local file paths to packs instead.

if drafting with an AI model is available, packs include refined cover-letter and CV-refinement suggestions; without an AI model, packs include deterministic template text and direct callouts from the role description.

all files use UTF-8 encoding and are written only to paths under <workspace>/liber8/.

outcome signal

the user knows liber8 worked when:

the local workspace was created without errors and the user can see config/, state/, output/, and inbox/ directories
the profile and resume files are populated (either by the user editing templates or by direct input during onboarding)
the first manual run completes and produces a non-empty summary.txt and manifest.json
the user can open and read at least one application-pack file (Markdown or DOCX) with relevant role details and tailored suggestions
if delivery is configured, the user receives a message on the configured channel with shortlist and attached packs (or file path links if attachments are not supported)
if a recurring run is enabled, the user receives scheduled messages on the configured delivery channel (or finds new shortlists in liber8/output/ if local-only) at the requested frequency
user feedback from shortlist reviews is persisted in the profile and visibly influences ranking in the next run (e.g., roles matching user-stated preferences appear higher in subsequent shortlists)