Fable's Back for a Week. Here's How to Actually Use It.

The most capable AI Anthropic makes is included on most paid plans through July 7, then it goes metered. Don't waste it on chat.

Last night I published Fable 5: The Night Agent, an account of three days in mid-June when I had brief access to Claude Fable 5, Anthropic’s frontier model, and pushed it through real family-history work: reading a single hard record to standard, reconstructing a circa-1872 county map from period sources, and, overnight, designing and running a first-pass extraction across a whole folder. That piece was a look back at something I thought was gone.

It isn’t gone. As of July 1, Anthropic restored Fable 5, and for a short window it is included on most paid plans. So where that piece looked back, this one is the working guide: how to use a scarce week with a frontier model on real genealogy, on purpose. (New here? Start with The Night Agent for what it can do; this is how to do it yourself.)

The clock

Here is the part that should shape everything else. Per Anthropic’s own redeployment notice, Fable 5 is included for up to half of your weekly usage limits on Pro, Max, Team, and select Enterprise plans through July 7. After that, it moves to metered usage credits. Fable’s list price is high because it is a frontier model, so after this week every use costs real money.

That turns a fuzzy question (”should I try the fancy model?”) into a sharp one: what is the fancy model actually for?

The one idea

Do not spend your Fable week on quick chat, summaries, or routine tasks. Everyday models do those cheaply. Spend Fable on the hard, long, ambiguous, high-judgment work: planning a research project, running a multi-step workflow, checking its own results, reading maps and messy documents, and supervising other models.

Said another way for our world: ask Fable to build research machinery, not just to hand you answers.

The week's core move, in one picture. This is an illustration, not a screenshot, but it is the idea the whole guide turns on. The large butterfly is Fable, the frontier model; the smaller ones are the cheaper models it directs, each carrying back a scrap of evidence. Spending your week well does not mean asking Fable to do everything itself. It means letting Fable plan the work, then hand the routine pieces down to cheaper, faster models and check what comes back. Architect and reviewer at the center; workers around it. Give it the goal and the guardrails, and it can run the team while you do something else.

Four moves that make the week pay off

1. Match the model to the work. Think in roles, not brand names. Use Fable as the architect and reviewer. Use cheaper, faster models (Claude Opus 4.8, Sonnet 5, Haiku, or GPT-5.5) as the prep team and the workers. Send bulk, well-defined work down to the cheapest model that can still do it well, and reserve Fable for the parts that genuinely need judgment.

2. Prepare before you spend. Don’t open Fable cold. Have a cheaper model help you write a short brief first: what you are trying to do, what you already have, what is stuck, and what a good result looks like. Then hand that brief to Fable. You are paying frontier prices, so walk in prepared.

3. Point it at a finish line. Fable is built to work for a long time without hand-holding. Give it a clear goal and let it run, checking its own work along the way, and tell it when to stop and ask you. Approve its plan before it starts the big work.

4. Keep the standards on. A more capable model does not lower the bar; it raises it. Keep uncertainty visible. Do not let it invent facts. Protect living-person privacy. And remember the oldest rule: the model produces language, and you supply the verification. It still produces words, not proven facts.

Which model, when. A pocket version of the first move. The costly frontier model earns its price on the hard part, architecture, ambiguity, orchestration, and judgment, so reserve it for that. Everything below it does the honest, high-volume work for less: Haiku for bulk reading and tagging, Sonnet 5 for everyday extraction and drafting, Opus 4.8 for harder review and prep. The skill this week is not using the best model for everything; it is knowing which rung each task belongs on, and routing the work down the ladder until only the genuinely hard parts reach the top.

Push further: let Fable run a team

The four moves are the whole method at small scale. Here is where a frontier model pulls away from everything else: it can run a team. Ask Fable to break a big job into parts, send cheaper models to work them in parallel, and then reconcile what comes back. Picture a reading room with Fable as the supervising researcher: one assistant works the deeds, another the census, another the newspapers, and a couple of skeptics whose only job is to try to disprove the findings before they reach your report.

The move that stretches a scarce week furthest is to let Fable act as a cost-aware router. Have it decide, for each subtask, the cheapest model that can do it well, and send the work there: bulk reading and tagging to Haiku, everyday extraction and drafting to Sonnet 5, harder review and prep to Opus 4.8, and only the architecture, ambiguity, and judgment to Fable itself. You are not paying frontier prices for filing; you are paying them for the thinking that decides how the filing gets done.

Give Fable your standards

You do not have to re-teach method every session. You can hand Fable a standards skill, install it once and invoke it whenever you work. Mine is the open Genealogical Research Assistant, which packages GPS methodology, the source-information-evidence model, and strict anti-fabrication rules into a reusable instruction set. Fable follows a compact standards skill well, and it will even adapt one on the fly as it works, so the discipline rides along with everything it does.

A few Fable quirks worth knowing

Fable behaves differently from everyday models in a few ways worth knowing before you start (all from Anthropic’s own Fable prompting guide):

• Effort is your main dial. Fable lets you set how hard it thinks. Use high effort for genuinely hard work and step down to medium or low for routine passes; it is the simplest lever on depth, speed, and cost.

• Expect long turns. Hard requests can run for many minutes, and autonomous jobs for hours. That is normal, not a hang; plan to check back rather than watch it.

• Watch for a quiet model switch. Fable’s safeguards route a small share of requests (Anthropic says the large majority of sessions are unaffected) to Claude Opus 4.8. If a reply suddenly feels different, check which model answered.

• Don’t ask it to show its raw reasoning. Prompts that tell Fable to reveal its internal chain-of-thought can trigger a refusal and a fallback to another model. Ask for its conclusions, evidence, and assumptions instead.

Watch me do it: three records from my own line

I will show you the method the way a chemistry teacher runs a demonstration at the front of the room, using three records from my own Lawrence family: two death certificates and an 1880 census excerpt. Here are the three records I handed Fable.

Record one: a 1916 death certificate. I began the demonstration the way I begin most problems, with a single hard record: the 1916 death certificate of David S. Lawrence, from Old Fields in Ashe County, North Carolina. A death certificate is really two documents in one, and Fable is asked to treat it that way. It carries primary information about the death itself, the fact and the date, but only secondary information about the birth date and the parents' names written near the bottom, details a grieving relative supplied from memory. The whole exercise turns on that distinction. What I want here is not a confident summary of the man's life, but a careful reading that keeps those two kinds of information apart, so the next record can test them.

Record two: an 1880 census excerpt. The second record widens the frame from a person to a household: the 1880 census for Old Fields, listing a David S. Lawrence among the people the enumerator recorded around him. This is where a careless reader leaps, taking "wife" and "son" as proven identity and stitching two families together. But the census says only what someone told the enumerator on one summer day, and the exercise asks Fable to hold it there, as household relationships stated rather than conclusions proven, with the surname left spelled as written, Lawrence or Laurence, and the variants intact. Set beside the death certificate, the census does not close the question of who this David was; it sharpens it, showing which links the two records can carry and which still need a third source.

Record three: a second death certificate. The third record is the most recent of the three, Henry A. Lawrence's 1955 death certificate, and it is what lets the exercise become correlation rather than description. Everyone named on it has long since died, so it can be shown whole. With two death certificates and a census now in hand, Fable can start to test whether these Lawrences of Old Fields belong to one another: whether the parents named on one certificate line up with the household on the census, whether the dates stay consistent, where the spellings drift. What I want here is not a verdict but the careful cross-reading that earns one, the agreements, the conflicts, and the questions a fourth record would still have to answer.

Here is what happened when Fable finally went live. I gave it the three Lawrence records, plus the compact Genealogical Research Assistant standard, and asked it to reason from the records rather than confirm a conclusion I already had in mind. The result was not a finished family history, and that is exactly the point. Fable turned the packet into a research problem: what do these three records, taken together, suggest about the relationship between David S. Lawrence, Margaret Lawrence, and Henry A. Lawrence?

Its answer was cautious in the right way. It separated the record-visible facts from filename metadata, treated the death certificates as stronger for death facts than for reported birth and parentage, preserved the Lawrence/Laurence/Lawerance spelling variants, and held the whole correlation at “Probable, Not Proved.” Then it named the next work a human should do: county marriage records, the 1900 census, later censuses, cemetery evidence, obituaries, and probate or land records. That is the kind of output I wanted to see: not proof, but a better map of the work.

This is the live Fable run, not a polished exhibit. At the top are the three Lawrence records and the compact GRA file I uploaded; below them is Fable’s first response. The important part is not the interface, though the warning at the bottom is useful: Fable draws down usage faster than Opus 4.8. The important part is the behavior. It held the census place and date as filename metadata, not record evidence; refused to turn “son” into proof of maternity; logged age conflicts instead of smoothing them; and labeled the result “Probable, Not Proved.” That is exactly what I wanted to test: whether a frontier model would spend its power on judgment, restraint, and next steps.

The full response came back as a markdown file, which is exactly the right shape for this kind of work: not a chatty answer, but an auditable worksheet. I do not expect anyone to read every line of it in a Substack screenshot. What matters is the structure. Fable made separate spaces for what the records say, what they correlate, what remains uncertain, and what should not yet be concluded. That structure is the lesson students can reuse even without Fable: make the model slow down, separate the layers, and turn uncertainty into the next research plan.

Fable’s first useful move was restraint. This screenshot is not the final answer to the Lawrence question; it is the worksheet Fable built before any answer should be trusted. It starts by saying what each record says on its face, then separates the convergences from the uncertainties, and finally names the conclusions that must not yet be promoted. That last section is the one I cared about most. A weaker model, or a careless prompt, might smooth the three records into a confident little lineage. Fable instead kept the hard parts visible: identity linkage, Margaret’s unknown maiden name, Henry’s mother, the informants’ relationships, and the recurring “652” annotation. This is what frontier time is for: not faster confidence, but better hesitation.

Now you try: duplicate mine, or use your own

Like any good demonstration, this one is yours to repeat. Follow the same steps on the same kinds of records, or better, on two or three of your own that ought to fit together. Use records for people who have passed on; be careful with anything that names living relatives, and never upload sensitive personal data you would not want retained.

Step 1. Upload the images together. Give Fable the two or three record images in one go. If Fable is not in your account yet, run the same steps with your best available model and switch later.

Step 2. Let the records set the question, then reason. Don’t hand it a conclusion to confirm. Paste a prompt like this:

I am uploading [N] record images about one family. Work only from the images; if you use the filenames as clues, label them as filename metadata, not evidence.

1. Look at the records first, then propose one research question these records can actually support. State it in a single sentence, and say why these records bear on it.
2. Identify each record's type, date, place, and whether it is complete or an excerpt.
3. Abstract only the fields needed for reasoning. Keep uncertain readings in brackets.
4. Build a table of atomic assertions. For each, give the record, the subject, the claim, where it appears, whether it is stated or inferred, the information type (Primary Information, Secondary Information, or Indeterminate Information), and whether it is Direct, Indirect, or Negative Evidence for the research question.
5. Separate what each record says, what the records together suggest, what stays uncertain, and what should not be promoted to a conclusion yet.
6. Flag every name and spelling variant.
7. Draft a genealogical statement following the Genealogical Research Assistant standard below: hold the conclusion at its honest level (Proved, Probable, Possible, or Not Proved), write a citation with any unverified parts left in brackets rather than invented, and list the record's gaps and the next sources that would strengthen it.
8. Give me a Needs-Review list of the next checks a human should make. Do not present this as a finished proof.

Standard to follow (the Genealogical Research Assistant, https://github.com/DigitalArchivst/Open-Genealogy/tree/main/skills/gra):
- Never invent sources, citations, people, dates, places, or events; if something is unknown, say so.
- Classify each source as Original, Derivative, or Authored.
- Label information only as Primary Information, Secondary Information, or Indeterminate Information; never say "primary source."
- Classify evidence only as Direct, Indirect, or Negative, always relative to the research question.
- A death certificate carries Primary Information about the death but Secondary or Indeterminate Information about birth and parentage; census household relationships are stated, not proven.
- Mark uncertain readings [unclear], [?reading], or [blank]; build citations from Who, What, When, Where, and Where-within, bracketing anything unverified.
- Protect anyone who may still be living.

Step 3. Read it like a genealogist, not a customer. Did it let the records set the question instead of forcing one? Did it hold the draft statement at an honest level rather than declaring proof? Did it treat what a death-certificate informant reported about a birth or parents more cautiously than the death facts themselves? Those behaviors, not a confident paragraph, are the point.

That is the whole method in miniature, and you can run it today with the tools already on your desk: separate source, information, and evidence; let the records set the question; keep uncertainty honest; and let a human make the call. Fable makes the work faster and more thorough. It does not make it proof.

If you take one thing from this

The window is the occasion, but the habit is the point. Even after July 7, the workflows, prompts, and templates you build this week keep working with everyday models. Spend the frontier where it earns its keep, and let the cheaper models carry the rest.

Don’t stress if you miss this week

One more thing, because I don’t want the clock to read as pressure. If you cannot get Fable this week, you have missed very little. The capability is what matters, and it is getting cheaper and more available fast. A comparably strong model at a fraction of the price is reportedly close behind (GPT-5.6 is expected very soon), and within roughly six months, open-weight models you can run yourself are expected to reach this class. What is scarce and expensive today will be ordinary before long.

So treat this week as a chance to practice the method, not a train you cannot miss. The genealogists who do well over the next few years will not be the ones who grabbed the best model first; they will be the ones who learned to think in workflows, projects, and gates while the tools raced to catch up. And they will race. The next year in this work is going to be, to put it plainly, a little unhinged, in the best way.

Appendix: the Fable Week prompt pack

Copy-ready prompts for the week. Use them beside the guide above. The rule holds throughout: prepare with a cheaper model, then spend Fable on planning, architecture, ambiguity, verification design, orchestration, and high-judgment review. If Fable is not in your account yet, run these with Opus 4.8, GPT-5.5, or another strong model; the method transfers.

Quick index

• Know whether to use Fable now — Prompt 0: access and surface check

• Prepare before Fable — Prompt 1: prepare my Fable brief

• Start a Fable run — Prompt 2: Fable sprint kickoff

• Decide what belongs to Fable — Prompt 3: find the hard parts

• Delegate to cheaper models — Prompt 4: design worker packets

• Run a worker chat — Prompt 5: worker execution

• Check output independently — Prompt 6: fresh-context verifier

• Combine worker results — Prompt 7: Fable reconciliation pass

• Preserve the method — Prompt 8: build reusable project instructions

• Add genealogy safeguards — Prompt 9: genealogy privacy and uncertainty block

• Preserve the week — Prompt 10: end-of-week harvest

Prompt 0: access and surface check

I am preparing for Fable Week. Help me record my current access and choose the right workflow path.

Here is what I can see in my account:
- Claude.ai model picker: [what I see]
- Claude Projects: [available / not available / not sure]
- Claude Cowork: [available / not available / not sure]
- Claude Code or another local coding assistant: [available / not available / not sure]
- API access: [available / not available / not sure]
- Fable 5 visible: [yes / no / not sure]

Based on that, recommend one of these paths:
1. Fable available now: prepare a high-value Fable run.
2. Fable not visible yet: prepare the brief with Opus/GPT and simulate the workflow.
3. No local tools: use chat/project workflow only.
4. Advanced/local path: use folders, instructions, worker packets, and verifier passes.

Do not assume I have tools I have not listed. Give me a short recommendation and the next three actions.

Prompt 1: prepare my Fable brief

I want to prepare a concise Fable Brief for a high-value genealogy project. Do not solve the project yet. Help me turn my notes into a clear brief for a frontier model.

Project: [name the project]
What I am trying to accomplish: [plain-language goal]
Why it matters: [decision, publication, class, research problem, or family-history purpose]
What I have: [records, notes, images, files, prior AI outputs, source lists]
What is stuck, messy, ambiguous, or too large: [describe the hard part]
Constraints: [privacy, living-person concerns, time, account limits, source limits, file limits, tools I can or cannot use]
Desired artifacts: [workflow, source ledger, conflict log, table, prompt, project instructions, report outline, review memo, checklist]
Definition of done: [what a successful result looks like]

Please produce:
1. A one-paragraph project brief.
2. A bullet list of the inputs Fable should receive.
3. A list of the hardest parts that may justify Fable.
4. A list of routine parts that should be delegated to cheaper models.
5. A clean Fable Sprint Kickoff prompt I can paste into Fable.
6. A short warning list: privacy issues, unsupported assumptions, and what must remain human judgment.

Prompt 2: Fable sprint kickoff

I am using Fable 5 during the July 1-7 restored-access window, so I want to spend it only on the hard parts.

Project: [name the genealogy or teaching project]
Goal and why: [what useful outcome this enables]
Audience or decision: [who will use the result, or what decision it supports]
Inputs available: [files, notes, records, images, prior outputs]
Current difficulty: [what is ambiguous, stuck, messy, or too large]
Constraints: [privacy, time, source limits, account limits, tools I can use]
Definition of done: [what a successful result looks like]

Use Fable for planning, architecture, ambiguity management, verification design, delegation, and review. Do not spend frontier effort on routine implementation unless the implementation itself is the difficult part.

Before acting:
1. Identify the hardest parts of the project.
2. Decide which parts Fable should handle directly.
3. Decide which parts to delegate to cheaper models, tools, or separate worker chats.
4. Create a workflow with checkpoints, artifacts, and verification gates.
5. State what requires human approval.

For genealogy work, separate source, information, and evidence. Preserve uncertainty. Flag conflicts. Do not invent missing facts. Protect living-person privacy. Treat any conclusion as provisional until human review.

Start by giving me the workflow plan and the delegation map. Do not begin large-scale execution until you have shown me the plan and named the checkpoint where I should approve continuation.

Prompt 3: find the hard parts

Review this project description and identify the parts that are genuinely hard enough for a frontier model.

Project description: [paste your project description, notes, or Fable Brief]

Classify the work into four groups:
1. Frontier-model work: hard, ambiguous, long-horizon, high-judgment, or architecture-level.
2. Strong everyday model work: summarizing, drafting, context compression, table cleanup, or ordinary review.
3. Tool or script work: repetitive operations, file inventory, renaming, format conversion, spreadsheet work.
4. Human judgment: privacy calls, living-person sensitivity, source interpretation, final proof judgment, publication decisions.

For each item, explain why it belongs in that group. End with a recommended first Fable request and a list of work I should do before spending that request.

Prompt 4: design worker packets

Turn this workflow into self-contained worker packets I can run in separate chats or cheaper models.

Workflow or plan: [paste the workflow]

Available worker types: context compressor, source inventory worker, record extraction worker, citation-gap worker, conflict-finder, privacy reviewer, drafting worker, verifier or skeptic, explainer for students.

For each worker packet, provide:
1. Worker role.
2. Goal.
3. Inputs to give that worker.
4. Exact copy-ready prompt.
5. Expected output format.
6. What the worker must not do.
7. How I should check the worker's output.

Make each packet self-contained. Do not require the worker to know the whole project unless that is necessary.

Prompt 5: worker execution

You are acting as a worker in a larger genealogy workflow. Stay inside this assignment. Do not broaden the project.

Worker role: [role from the worker packet]
Goal: [goal from the worker packet]
Inputs: [paste only the relevant sources, notes, or excerpts]
Output format: [table, list, memo, checklist, CSV schema, etc.]

Rules:
- Do not invent missing facts.
- Separate what the source says from what you infer.
- Mark uncertain readings.
- Flag conflicts and gaps.
- Protect living-person privacy.
- If the assignment cannot be completed from the inputs, say what is missing.

Complete only this worker task. End with a short "Needs Review" list.

Prompt 6: fresh-context verifier

You are a fresh-context verifier. Your job is not to improve the writing. Your job is to find errors, unsupported claims, missing checks, privacy issues, and overconfident conclusions.

Source material: [paste source text, record description, source notes, or links if available]
Output to verify: [paste the draft, table, plan, or conclusion]

Review for:
1. Claims not supported by the provided source material.
2. Source, information, and evidence confusion.
3. Missing uncertainty flags.
4. Conflicts ignored or smoothed over.
5. Citation gaps or bracketed elements that need verification.
6. Living-person or sensitive-data risks.
7. GPS-aware language problems: any suggestion that AI achieved, guaranteed, certified, or completed proof.
8. Places where human judgment is required before use.

Return a table of issues ordered by severity, the exact text at issue, why it is a problem, a suggested correction or next check, and a final go / revise / do-not-use recommendation. Do not praise the output unless it is needed to explain a risk.

Prompt 7: Fable reconciliation pass

I have worker outputs and verifier reports from a multi-part genealogy workflow. Reconcile them into a single auditable result.

Original project goal: [paste goal]
Fable workflow plan: [paste plan]
Worker outputs: [paste or summarize outputs]
Verifier reports: [paste verifier findings]

Please:
1. Identify agreements across workers.
2. Identify conflicts or inconsistencies.
3. Separate source statements, information extracted from sources, and evidence-based inferences.
4. Mark every unresolved uncertainty.
5. Decide what is safe to keep, what must be revised, and what must be discarded.
6. Produce a final artifact in this format: [table / memo / checklist / source ledger / conflict log / report outline].
7. End with a human-review checklist and a next-research plan.

Do not smooth over uncertainty. Do not treat model agreement as proof. If the evidence is not sufficient for a conclusion, say so plainly.

Prompt 8: build reusable project instructions

Turn this successful workflow into reusable project instructions for future genealogy work.

Workflow that worked: [paste workflow, prompts, outputs, or notes]
Future use case: [describe the kind of records, project, or writing task this should support]

Create reusable instructions that include:
1. Project purpose.
2. Input expectations.
3. Source, information, and evidence handling.
4. Uncertainty and conflict rules.
5. Privacy rules.
6. Output formats.
7. Verification gates.
8. When to ask the human before continuing.
9. What to delegate to cheaper models or tools.
10. A short "first prompt" for starting a new session with these instructions.

Keep the instructions clear enough for a genealogist to understand and strict enough that a model can follow them.

Prompt 9: genealogy privacy and uncertainty block

Add this to any prompt that touches real family material.

Genealogy standards and privacy rules:
- Do not invent missing facts, dates, names, places, relationships, citations, or sources.
- Separate source, information, and evidence.
- Mark uncertain readings and alternate interpretations.
- Flag conflicts instead of resolving them prematurely.
- Treat conclusions as provisional until human review.
- Protect living-person privacy. If material may concern living people, sensitive family details, DNA, adoption, non-paternity events, health, legal matters, or private correspondence, flag it and ask before using it in any public-facing output.
- Use GPS-aware or GPS-supporting language only. Do not say the AI completed, achieved, certified, guaranteed, enforced, or complied with the Genealogical Proof Standard.
- End with a "Needs Human Review" list.

Prompt 10: end-of-week harvest

Help me harvest what I built during Fable Week so it stays useful after Fable moves to usage credits.

Here are the prompts, plans, outputs, and notes from my work: [paste or summarize]

Please produce:
1. A list of reusable workflows.
2. A list of reusable prompts.
3. A list of project instructions or templates worth preserving.
4. A source ledger or artifact inventory.
5. A list of unresolved questions and next actions.
6. A recommendation for what can now be handled by everyday models.
7. A recommendation for what, if anything, is worth future metered Fable use.
8. A brief lesson learned: what frontier-model work was truly worth it?

Keep this practical. The goal is to preserve machinery, not to memorialize every chat.

Sources

• Anthropic, “Redeploying Fable 5,” for the July 1 restoration and the included-usage window through July 7.

• Steve Little, “Fable 5: The Night Agent,” the companion piece this post follows.

• Open-Genealogy: the Genealogical Research Assistant skill.

• Anthropic, “Prompting Claude Fable 5,” for the Fable-specific behaviors (effort, long runs, subagents, and the Opus fallback).

---

Disclaimer. This post is educational and shared “as is.” You are responsible for verifying all AI output and for your own research decisions; neither Steve Little nor Vibe Genealogy / AI Genealogy Insights is liable for any outcome that results from using it. Designed to support GPS-aware research; it does not claim any AI tool achieves, guarantees, or completes the Genealogical Proof Standard.