Personalized AI infrastructure
Superintelligence Starts With Records: Turning Paper Job Files Into Memory
A realistic sequence for turning paper job files into structured company memory, with approval boundaries, so future AI agents can use it safely.

AI for paper records in a small business starts with a sequence, not a scanner. Decide which questions a future agent must answer, sort the paper that supports those questions, convert each job file into a fixed record with visible sources, and only then give an agent limited read access. Paper becomes company memory when every fact can be traced back to a page that a person can check.
Key takeaways
- Choose the questions the agent must answer before you scan anything.
- Sort the archive by job type and keep open jobs separate from closed ones.
- Use one record template per job type, with a source reference on every fact.
- Give agents read access to verified records only, and keep any write action behind human approval.
- Test retrieval with real questions, including questions the archive cannot answer.
Start with the questions the agent must answer
A digitization project without a target becomes a storage project. Boxes get scanned, files get renamed, and nobody can say later what the archive is for. The fix is to write down the three or four questions that someone in the business asks repeatedly and that a well-organized archive could answer. For a service company, these are usually about past work: what was agreed for a similar job, which materials were used, who approved a change, and what the client was told in writing.
Use the questions to decide what belongs in scope:
- If the question is about a past job, you need the job file, its dates, and its approvals.
- If the question is about a quote or an invoice, you need the pair of documents and the date each one was issued.
- If the question is about a customer preference, you need the note the crew wrote and the name of the person who wrote it.
- If no one will act on the answer, leave that part of the archive in storage and out of the first project.
This step also protects you from over-collecting. Job files often contain personal data such as addresses, contact details, and identity copies. A narrow scope means fewer sensitive pages enter the memory layer in the first place.
Sort the paper before you digitize it
Sorting is slow work, and it is where most of the errors are prevented. Set up a simple intake area with labeled trays or boxes, and assign one person to make the first pass. Their job is to separate material, not to read every page closely.
A practical checklist for the first pass:
- Separate open jobs from closed jobs, and mark any job with a warranty or dispute period still running.
- Pull out originals that carry legal or tax weight, and keep them under your existing retention rules rather than discarding them after scanning.
- Remove duplicates, blank forms, and drafts that were superseded by a signed version.
- Flag handwriting that only one or two people can read, and ask those people to annotate the page while they are still available.
- Log which box or folder is with which person, so no file is scanned twice or lost during the process.
Keep a count of what you set aside and why. That log becomes the first piece of documentation for the memory layer, and it will be useful when someone asks why a particular job is missing.
Design one record template per job type
A paper file is a pile of pages. A record is a structure that an agent can read reliably. The bridge between the two is a template, and the template should be short enough that a busy coordinator can complete it in a few minutes for each job.
A workable sequence for building the template:
- Name the job types you will start with. Choose one type with high volume and clear outcomes, not the most complicated one.
- Define the header fields: an internal job reference, the opening and closing dates, the responsible person, and the job type.
- Define the body fields: the agreed scope in one sentence, the materials or inputs used, each approval with its date and channel, any change after approval, and any issue still open.
- Add a source field for every fact, pointing to the scanned page and its position in the file.
- Test the template on five real files from the same job type, and remove any field that nobody could fill from the paper.
Keep the template to a single page. If it grows beyond that, people will skip fields, and the record will quietly lose the detail that made it useful. For guidance on how written standards support this kind of work, see Documentation Standards for a Superintelligence-Ready Company.
Extract facts, check them, and keep the source attached
Once the template exists, you can move the scanned pages into it. Optical text recognition reads the typed parts reliably and the handwritten parts less so. Treat extraction as a draft, and make human review part of the process rather than an exception.
Illustrative scenario: a small kitchen installation company keeps one folder per remodel. In one folder, the client's approval of a tile change is a photo of a handwritten note. The extraction step fills the approval field with the text it reads and marks the field for review. The coordinator confirms the wording, adds the date of the message, and the record stores the page reference. Months later, an agent asked whether the client accepted the tile change can answer and show the page, without guessing from a summary.
This is the core of retrieval-based design. The agent does not memorize the archive. It looks up the verified records when a question arrives and answers from them, which is the pattern described in the [Google Cloud retrieval-augmented generation architecture](https://docs.cloud.google.com/architecture/rag-capable-gen-ai-app-using-vertex-ai). The quality of the answer depends directly on the quality of the record and the presence of its source.
Decide what the agent may read and write
The memory layer should not be open to every tool and every user. Permissions need to be designed before the agent goes live, and they should be deny by default. The [OWASP authorization guidance](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html) makes the same point for applications in general: each request should be checked against an explicit rule, not assumed to be allowed because the user is inside the company.
A useful boundary for a first agent looks like this:
- Read access to verified records of the chosen job type, and nothing outside that scope.
- Write access limited to draft fields that a person reviews before they become part of the record.
- No action that sends information to a client, changes a quote, or alters an approval without a named human signing off.
- Treat text inside scanned documents as data to be read, never as instructions to follow. A handwritten note or a pasted message can contain words that look like commands.
Write these boundaries down in a short document that names the agent's role, its data sources, and the people who approve exceptions. The AI agent permission review guide describes how to check those boundaries on a schedule, which matters because roles and staff change.
Test retrieval before any agent relies on it
A record that looks complete can still produce wrong answers. Before you let anyone rely on the agent, test it the way you would test a new employee. The [Anthropic guidance on evals for AI agents](https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents) treats evaluation as a set of repeatable tasks with known correct outcomes, and that framing fits a records project well.
Build the test set from real questions. Ask the people who will use the agent to write down what they would ask in a normal week. Include three kinds of questions: ones the archive answers clearly, ones it answers only partly, and ones it cannot answer at all. The last group is the most important, because a good agent says so instead of inventing an answer. For each question, check the agent's response against the source page, and record every failure with its cause: a missing record, an unclear field, a wrong date, or a permission that blocked access.
Repeat the test after each change to the template or the data. A test set that never changes stops being useful, so add a new question each time someone asks something the agent got wrong. The proof-of-concept, pilot, and production guide explains what each stage should prove before the next one begins.
Keep the memory current and close the gap to production
The archive will not stay complete on its own. Once the first job types are structured, new jobs should be created directly in the template, so the paper stage gradually shrinks. Schedule a short review each quarter to check that records are being completed, that the source references still open to the right page, and that the agent's permissions still match the people who use it.
Be Human designs and operates this layer as part of managed operations. The work covers defining the record templates and memory boundaries for one useful agent role, implementing retrieval and permissions, running recurring evaluations, and reviewing access and integrations as the business changes. The client keeps control of the company's identity, memory, approvals, and permissions, and every change to them goes through a documented request.
The free Be Human AI diagnostic can help you find the first job file worth handing to an agent.
Frequently asked questions
Do we need to scan every paper file before an AI agent can help? No. Start with one job type that produces the questions your team asks most often, structure those records, and test the agent on them. The rest of the archive can wait until the first layer works and has been reviewed.
Is it safe to put job files that contain customer personal data into an AI system? It can be, but only with a narrow scope, clear access rules, and a review of what personal data each record holds. Remove fields you do not need, limit read access to the people and agent roles that require it, and check the data protection rules that apply in your country before you connect anything.
What if the handwriting is too hard for extraction to read? Keep the scanned image as the record of truth and let a person type the key fields, such as approvals and dates, with the page reference attached. Extraction can still help with typed sections, and the review step catches what the software misreads.
How do we know the agent is answering from our records and not guessing? Require a source reference with every answer, and test the agent with questions the archive cannot answer. A well-configured agent says that the record does not contain the answer, and each factual answer points to a page someone can open and check.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


