· 6 min read
What I keep on paper instead of in a system
An AI automation operator on why certain analogue records never make it into a searchable system, and where the real line sits between convenience and exposure.
The stack that nothing reads
Most of my work day is spent making sure machines can read things. Content calendars live in structured files an agent can parse. Render logs get written so a script can check them later. Task queues sit in a database because a queue that only a human can read is just a to-do list, and to-do lists get ignored. If I can wire it into an agent, a cron job, or an MCP tool, I generally do, because that’s the whole point of running AI in production: you stop being the bottleneck between an idea and the thing that executes it.
And then there’s a notebook on my desk. Cheap, spiral-bound, handwritten. Nothing in it is formatted for a parser. Nothing in it is backed up to a cloud drive. It has no API. That’s not an oversight. It’s the entire reason it exists.
What goes into a system, and why
Before getting into what stays on paper, it’s worth being precise about what belongs in a system in the first place, because the two categories aren’t “important stuff” versus “unimportant stuff.” Plenty of important things live in systems.
Anything that benefits from being retrieved, searched, summarized, or acted on by something other than me goes digital. A content calendar needs to be read by a script that checks what’s due. A render log needs to be greppable when something breaks at 2am. A list of which servers are running which service needs to be a file an agent can check before it tries to restart something. The value of putting something into a system is that a system, or an agent with tool access, can do something with it without me sitting in the loop.
That’s a real trade, not a free one. The moment something is in a file, a database, or a vector store, it’s reachable by whatever has read access to that file, database, or store, including an AI agent with a broad tool scope, and including a cloud model if the pipeline sends context off the machine. Most of the time that’s fine, because most of what I automate is operational: schedules, statuses, queues. None of it is dangerous if an agent reads it, quotes it back to me, or hands it to another tool in a chain.
The line: what an agent could do with it
The paper notebook holds the things where the honest answer to “what happens if an agent reads this and acts on it, or a prompt injection tricks it into repeating this somewhere” is: something I don’t want.
Concretely, that means:
- Recovery codes and master credentials for anything that would let someone take over an account, a domain, or a server if they got hold of them.
- Physical access details, things like who has a key or a code to a location, and the order in which systems depend on each other so that one failure doesn’t cascade.
- Notes on single points of failure across the whole setup, the kind of list that’s genuinely useful for me to have in one place but genuinely bad for anything automated to ever surface.
- Half-formed ideas I haven’t decided I want written down anywhere permanent, let alone summarized or indexed.
None of this is a claim that current models are scheming or untrustworthy in some dramatic sense. It’s simpler than that. An agent with file or tool access does what its instructions and its context tell it to do, and both of those can be manipulated in ways that are hard to fully rule out, whether that’s a misconfigured permission scope, a bug in how a tool call is chained, or a malicious instruction hidden inside a document the agent was asked to read. The failure mode isn’t “the AI decided to betray me.” It’s “the AI faithfully did what it was told, and what it was told came from somewhere I didn’t check.”
Local doesn’t mean isolated
It’s tempting to think running models locally solves this, and it solves part of it. A model running on your own hardware doesn’t send your context to someone else’s servers, doesn’t get logged by a third party, and isn’t subject to whatever that provider’s data handling policy says this quarter. That’s a genuine advantage and it’s a real part of why I run local models for anything I don’t want leaving the machine.
But local isn’t the same as isolated. If you’ve given a local agent broad filesystem access, or wired it into MCP servers that can read multiple directories, or set up a workflow where a local model hands a summarization task off to a cloud API when the context gets long, the “local” part of your setup stops being the whole picture. The agent can still read a file, still act on it, still pass it along to the next tool in the chain. The question was never just “where does the model run.” It’s “what can this thing reach, and what happens if it reaches the wrong thing at the wrong moment.” Paper has no filesystem for anything to reach.
Why paper specifically
Paper isn’t a security product. It’s not encrypted, it’s not access-controlled, and if someone physically finds the notebook, they can read every page. The reason it still earns a place on my desk is what it’s immune to, not what it protects against.
It can’t be indexed by a semantic search that someone builds later without thinking hard about what it just made queryable. It can’t be swept up by an agent that was told “read everything in this folder and summarize it” and didn’t know to stop. It can’t be exfiltrated by a prompt injection sitting inside some other document, because it was never part of an agent’s context window to begin with. It doesn’t get copied when a backup script runs, and it doesn’t show up when someone connects a new tool to an old vector store and forgets to check what’s in there.
The trade is real. A notebook can be lost, damaged, or physically stolen, and it doesn’t benefit from any of the automation I use for everything else. That’s a legitimate cost, and it’s why not everything belongs on paper. If losing a piece of information would hurt more than someone digital finding it, it needs a different kind of protection, encryption, access control, or splitting it up, not a spiral notebook. Paper earns its place specifically for the things where the reverse is true: where the damage from a system reading it and doing something with it, deliberately or by accident, is worse than the inconvenience of it living in one physical place I control.
Being deliberate about what a system can see
Running agents in production teaches you a specific kind of discipline that doesn’t show up in the demos: you spend as much time deciding what a tool can’t reach as you do deciding what it can. Giving an agent broad access is easy and it’s often the thing that makes a workflow actually useful. The harder, less visible work is drawing the boundary before you give that access, not after something has already crossed it.
The notebook is that boundary made physical. It’s a short, deliberate list of the things I’ve decided don’t belong anywhere a model, an agent, or a badly scoped tool call could ever touch. Everything else, the vast majority of what actually runs the operation, lives in a system, because that’s where it’s useful. The paper isn’t a retreat from automation. It’s what makes trusting the automation for everything else reasonable.
If you want to see how the rest of this actually runs, from local rendering to how agents get wired into real tools, head back to the homepage.
Get new guides and videos first — join the Telegram channel.