A city, a stack of old books, and a promise
Every genealogist knows the feeling of searching for that one record that answers The Big Question. This is a story about how a team of dedicated volunteers worked tirelessly to help you answer that question, and how a new AI assistant called Fable 5 is helping bring it home.
(If “Fable 5” doesn’t mean anything to you, it’s the newest AI model from Anthropic, and currently the hottest thing since sliced bread.)
But, back to our story.
In the 1870s, Victoria was a young city on the western edge of the continent. It was truly the wild, wild west. Its police department did a booming business keeping the town safe. As part of their efforts, they kept charge books: ledgers that recorded who was brought in to the police department, and why. Names of the accused, the victims, and the witnesses to the crime. Charges of theft, drunkenness, and assault cover the pages. Although often tough to read, these books are filled with stories of life in a frontier town, in the handwriting of the people who lived it.
More than a century later, those fragile books were found and carefully scanned so that the stories they held could be told and retold. Once the scanning was done, the real labour of love began: creating an index for the pictures so that genealogists could search them, and one day find a mention of their ancestors. That labour fell to the dedicated volunteers of the Victoria Genealogical Society. This is their story. I have been lucky enough to help them write the last chapter in their book.
This is also a story about why that last chapter nearly didn’t get written. Projects like this get stuck just short of the finish line all the time, not for lack of skill or devotion, but because the final step, pulling years of careful work by many hands into one consistent whole, is a special kind of problem. Three kinds of knots tend to tie projects like this one up. This project had all three.
The Victoria Police Department Charge Books Project
Between 2014 and 2017, roughly sixteen volunteers indexed those charge books into spreadsheets. Six charge books were indexed, covering the years from 1873 to 1876.
Every entry was typed by one person, then checked by a second, and often a third. Thousands of entries, each a small act of devotion.
If you have ever transcribed a census page, you know the patience it takes. You know how easy it is to make a slip, and how hard it is to catch it. Now imagine doing that with sixteen people for four years.
The next step in the plan seemed simple enough. Gather all of the separate spreadsheets together and put them into one consistent, searchable index. Then hand it, along with the scanned images, to the University of Victoria Library so that they would be accessible to the public for research for the long term.
The images were scanned. A large set of separate indexes were finished. Their consolidation and connection to the images was not.
Let me introduce you to the knots.
The first knot: many hands over many years
Ask sixteen people to type “drunk and disorderly” a few thousand times over four years, and you will get it spelled, capitalized, and abbreviated more ways than you can imagine. One volunteer writes dates one way; another writes them a different way. One reads a scrawled abbreviation as one thing; a teammate reads the same scrawl as something else.
None of this is carelessness. Every choice is reasonable on its own. But over a long project, each person settles into their own small habits and their own readings of instructions. Try as they might, no team on earth can fully prevent it. And ours tried hard.
What you’d end up with is a set of spreadsheets that almost, but not quite, speak the same language. And “almost” is the whole problem, because a search only finds what it actually matches.
The second knot: the books themselves kept changing
The drift did not start with the volunteers. It started in the 1870s, in the police station itself.
Six charge books, filled in across four years by whoever had the duty desk. Different hands, different habits, different ideas about what to write down and how to write it. The way an offence got named in 1873 was not quite the way it got named in 1876. One era’s “vagabond” would become another era’s “vagrant.” The books disagreed with each other before anyone ever tried to index them.
So the volunteers were not simply transcribing. They were interpreting, each in their own careful way, source books that were already inconsistent among themselves. Two layers of drift, one laid on top of the other, and all of it waiting to be reconciled on the day someone tried to merge everything together.
The third knot: just another day at the office
The third knot is the one I recognize most painfully from my working life, because it is not about data at all. It is about teams.
This effort was really two projects, run by two different teams with two different jobs. The volunteers were building an index. The library staff at the University of Victoria were solving a related but different problem: how to take thousands of scanned images and present them to the public. Both teams doing important work, and, as happens so frequently, each taking a slightly different walk through the woods on their way to grandma’s house.
When the library took custody of the scans, they prepared to load them into the system that they would use to share the scans with the public. Somewhere in that process, the scanned images were renamed for what, I’m sure, seemed like perfectly valid reasons at the time. The depressing impact of this change is that the links between the indexes and the images were broken.
I wasn’t on this project at the time, but I have been in that meeting a few times. I can only imagine the choice words that were shared. Thankfully, the project team didn’t give up on it. They fixed every one of those broken references by hand. This kind of bare knuckle data management is careful, thankless work that generations of researchers will never know to thank them for.
This is just one of the many things that slowed the project down enough that it lost momentum. Between the technical wrinkles, the shifting availability of volunteers, and the plain gravity that tugs at any long project, the consolidation never happened. The spreadsheets were set down, and there they sat for the better part of a decade.
The knots usually win
Big projects like this aren’t that different than your own genealogy research. You are almost finished for want of the last step. I have watched what happens next many times. Nothing happens. The knots win.
Untangling them means that somebody has to roll up their sleeves and figure it all out again. Reconciling every drifted spelling mistake and changed habit, across dozens of spreadsheets holding thousands of rows referencing hundreds of scans. It is such a brutal challenge that most stalled projects never manage to restart.
What researchers inevitably inherit are several similar-but-not-quite-matching record sets, and an unspoken instruction: good luck, have fun, sort out the differences yourself. Not because anyone failed. Because holding it all together, at that scale, on volunteer hours, is simply too hard.
What changed the odds this time was a new kind of help. And even then it took two tries to get it right.
Enter the chatbot
Before family history became my second act, I spent thirty years trying to help companies make the most of the information that helped them run their businesses. In other words, I spent a good part of my career untangling other people’s messy data.
So, when someone asked whether the charge book index could be pulled together, I had a fair idea of the problems that might be waiting for me when I looked under the hood. To be quite honest, I wasn’t sure I wanted to look. But then, in late 2025, the time was right for a few of my genealogy colleagues and me to get together with some of the original project members and get the low down. I still thought it was going to be hard, but it might be possible.
Then, I called on my AI assistant, starting the way most of us used AI at the time: in a chat window in my web browser. I uploaded a handful of spreadsheets, along with some of the project documentation, and asked the assistant to look it all over using some time-honored data analysis techniques. We talked through what it found. It was genuinely useful, and at times it felt like magic.
From there, it turned into a proper detective story. We found folders of files nobody had mentioned. We got to the bottom of errors in spreadsheets. We teased out patterns that suggested this might actually work. Thrillingly, the picture was coming together.
But, Claude Opus 4.5 (the best AI model available at the time, and an older cousin of the Fable 5 I would turn to later) and I couldn’t quite make everything fit. My chatbot was telling me that we had the answer, but my experience was telling me that it was a hallucination. So, like those that had come before me, I put things down, promising to get back to it “someday.”
New AI tools and new AI models
Fable 5 became available on July 1, 2026. It is the newest and most capable AI model from Anthropic, the company behind the Claude AI chatbot. There was a catch: Anthropic signalled that they were going to change how they charge for Fable on July 7, making it much more expensive. So, I wanted to throw a genuinely hard problem at it while I could still afford it, and I couldn’t think of a harder one than this.
But the new model was only half of it. The other half was where it could do its work.
Unlike my 2025 AI assistant, which lived inside a browser tab that could only hold a dozen or so files, my 2026 assistant could run right on my own computer. Think of the difference between passing someone a few photocopied pages through a mail slot versus handing them the key to your whole filing cabinet. It could open any of the thousands of files on my hard drive, and look at every spreadsheet and image that I gave it access to.
For the first time, it could see everything the volunteers had made, and worked on, all at once.
When we sat down with the full set of files and started counting, the totals refused to match what I had reported before. Not by a rounding error. But by thousands.
So Fable and I stopped and asked the boring, unglamorous question that a career in data analysis had drilled into me. Where, exactly, is this information coming from?
A man named Joe
Here is what we found. Every workbook included the same template and tutorial. A few hundred pretend entries that showed a new volunteer what finished work should look like. The first of them included a man named Joe, charged on the 4th of April 1873.
That same tutorial page was sitting inside every one of the eighty-two workbooks. A few hundred pretend records, times eighty-two, is tens of thousands. Whoops.
Opus 4.5 had completely missed this, and being new to the project, I didn’t know the data well enough to see it.
Stupid AI?
It would be easy, and lazy, to make this a story about AI screwing things up. It had reasoned carefully. Given the data it was handed, its logic held up. The trouble was it hadn’t seen all of the data.
Working through a chat window, it could only open the handful of files I had chosen to upload. And when it opened one, it reached for the first page it found. That page was the sample. It answered my question thoroughly and confidently, about the wrong page, and it never saw the right one, because I didn’t know enough to tell it to, and it hadn’t seen enough of them to ask.
What changed?
First, letting the assistant off the leash of the browser and onto the actual drive, where it could look at every file. Second, a hard lesson learned from a few decades of looking at data: never trust the report until you verify the data yourself.
This is the thing I keep telling anyone who will listen about AI tools. Use them to do the work that you are already good at. I didn’t catch the problem by being a cleverer prompter, or by trusting the machine more. I caught it because decades of ferreting out tough data challenges told me that things didn’t seem quite right. And, the only way to know for sure was to tick and tie every index row against every scan. Unfortunately, I didn’t have a team of people who could do the heavy lifting. But, for the first time, I had a tool that could make light work of it.
The real number
Once we had verified all six books, we found almost eighteen thousand records. Fewer than I first thought, but this time every one of them was real.
Each real person, on a real day, in a real charge book, in a young city on the edge of the continent.
And with the actual count in hand, I could get to the work that had been waiting since most of the volunteers had set theirs down: the knots.
Where Fable earned its keep
Remember the three knots? Here is what this new way of working did about them.
For the first time in the life of this project, one tireless reader could hold the entire tangled mess in view at the same time. All eighty-two of the volunteers’ workbooks, more than thirteen hundred scanned pages, nearly eighteen thousand index entries. Not a sample. Not a handful of uploads to spot check. Everything.
Patterns you could never spot from inside one spreadsheet jumped out when all of them could be read side by side. The different ways sixteen people spelled the same charge over four years, the place where one book’s habits ended and the next one’s began.
Fable could find the seams, sort the variations into piles, and show me exactly what needed reconciling, with nothing left uncounted. And because it could read the scans as well as the spreadsheets, it could put the most important question to the test: did every index entry point at the right image? I will come back to that one, because the volunteers deserve to have the answer told properly.
Better still, we never had to guess whether a consolidation idea would work. If we wondered whether charges should be grouped this way or that, we did not debate it or write a memo about it. We tried it and looked at what happened. Keep what works, drop what does not, run it again. I supplied the judgment about what to try, and what to set aside for human eyes, and then Fable supplied the tireless hands.
This combination is one of the real breakthroughs of the AI age. You coming up with ideas, a machine doing verifiable work, and then verifying it against everything to confirm if it actually worked.
Proving it, one step at a time
I did not want to turn the AI loose on all six books and hope for the best. So, we proved it on one book first. Another lesson from the school of hard knocks: many small steps win the battle.
Our small test came out with some errors, but with a little work, we were able to account for every one.
This test didn’t just prove out the approach, it also found some data that I had initially thought had gone missing. Somewhere over the years, one of the spreadsheets had lost its entire column of first names. Simply gone. One backup copy still had them. By laying everything side by side, dozens of people quietly got their first names back, going from a bare surname to a whole name again.
If you have ever found an ancestor listed as nothing but a lone last name, you know exactly how much that will matter to someone someday.
Then, against all six charge books
With the method proven on one book, it was time to try it against all six. I’ll be darned, it worked! The single index now holds every one of those almost-eighteen-thousand records.
The promise of a verifiable process
I can already hear the comment section blowing up! How do you know that it isn’t all one big hallucination? Chatbots lie! You can’t possibly verify all of that by hand!
Data integration and system migration teams have been dealing with this problem for fifty years and have long since solved it.
The volunteers’ files are read and left exactly as they were, and every result is written to completely new files. Nothing is ever changed in “secret.” When the process tidies up something, say, a term that three volunteers spelled three different ways, the original spelling is kept right there beside the normalized one. You never want to risk losing anything that was written, and you always want to be able to see what was done so that you can change your mind later if you want to.
And then, anything that cannot be reasonably assumed from the files themselves is set aside for a person to decide, using the scanned pages if necessary. The machine does the tireless sorting. People make the judgment calls with a clear line of sight to the original records.
The original work was rock solid
By every check we could run, it was (almost) perfect. The little that wasn’t was easy to explain. Dates written a few different ways here, uneven capitalization there, differences in the use of spaces, padded zeros (or not), several kinds of hyphens. The kind of things that would blow up a data consolidation project, or trip up your search engine, but nothing that changed a historical fact.
And remember that patient, thankless job of realigning the picture references by hand, after the two teams took their different walks through the woods? Fable was able to check every one of those references against the actual images. Every index entry pointed at the page it was supposed to.
Every issue that we could find was fixed, explained, or traced back to a real, documented quirk of the physical books. Nothing was lost in the indexing. It only seemed that way until everything was checked, exhaustively, by Fable.
All the drift we were concerned about in the first two knots was real, but the ropes were easy to untangle.
So, is it finished?
Honestly? Based upon my experience, the hardest part is.
What stands between this and an index you can search online is now manageable. It is not more coding, and it will involve very little AI. What is left involves people.
The next big task is careful review of Fable’s work by the very people who were there when the indexing and the scanning were done the first time. What assumptions did I get wrong? What mistakes did Fable make? Because here is the one rule I won’t bend for any AI tool, Fable included: never trust the machine. The last word belongs to human verification and testing.
And that is the most important part of my Fable project this week. Not the consolidated index itself, but the process behind it, built to be both efficient and verifiable. Easy to rerun when an expert finds a mistake that we need to fix, and transparent enough that a person can hold every decision up against the original indexes or scans and see exactly what was done and why. An answer you cannot verify is just a well-dressed guess.
Then will come the work of putting it all online so the public can search it. That, after all, is the part that matters most. And, I almost forgot, there will be paperwork. Why is there always so much paperwork?
These conversations will begin again in the fall, and they will go at the pace of people, because the verification and the final decisions (and the paperwork) need to be right, not fast. But the index itself is (almost) ready. The thefts and the drunk-and-disorderlies, the victims and the accused, and the shape of an ordinary day in a young frontier city that they describe. All of it written over a century ago, transcribed over a decade ago, by volunteers who believed it was worth saving.
What this has to do with your own knots
You are almost certainly never going to index six frontier police ledgers. So why should any of this matter to you?
Because the thing that changed here is now within reach of anyone with a messy pile of family data. For the past three years, AI has lived behind a chat window that could only glance at a few files at a time. Now it can work directly on your own computer and do the work rather than just talk about the work that you should do.
And don’t forget the three old IT-guy habits that made this project work. All of which scale all the way down to a few dozen records about a stubborn branch of your family tree:
- Break a hard problem into many small ones. I didn’t turn the AI loose on all six books. We proved the method by analyzing first, deciding how to approach the problem, trying it out on one book, explaining every mistake, and then running it on the rest once we had the kinks worked out. Many small, verifiable steps win the game.
- Keep your original records untouched and every change out in the open so you can easily see what was done and why.
- Never trust a result you have not verified, no matter how confident the tool sounds. Use AI to do the work you are already good at, and let your own hard-won judgment tell you when something is not quite right. Verify, verify, verify!
If you would like to learn a bit more about the actual method used here, rather than the war story version this post lays out, I wrote a step by step guide for turning your everyday AI tool into a small research team in an earlier post. That is the place to start if you want to try something like this yourself.
Stay tuned
This story isn’t over. The human review, the final painstaking decisions, and the last minute challenges that will pop up putting the index online are all still ahead of us. I will keep you posted as the project moves from almost finished to actually finished. When those records are live and searchable, you will hear about it from me here first.
Have you got a project that has sat unfinished for years because it has you tied up in knots? I would genuinely love to hear about it, and what ideas you have now for untangling them.
Leave a comment below and let’s compare notes.
0 Comments