Answer it once

Saturday night an inquiry came in through my website for a land job way too big for my crew. About four months ago I'd put together a bid on a similar job with a partner who runs a much bigger outfit. I barely remembered it, and when I asked my agent about it, I described it wrong.

About ten seconds later it had found the right job anyway, corrected my acreage from our notes, pulled up what the partner had priced it at, and used that to tell me its first estimate on the new job was too low. I didn't open a folder or scroll a text thread. I didn't call anybody to ask "hey, what did we land on for that one?"

Fifteen minutes earlier I'd posted a thread in our Discord that was making the rounds, a "second brain in five minutes" setup, with the caption "second brain takes 5 mins." Then: "all these countless hours Ive spent with gbrain are complete waste of my time." I was being sarcastic. The ten-second answer is what those hours bought.

This issue starts a series about that system: what it is, how to build one, and what it really costs to keep running. I'm calling it Answer it once, because that's the whole idea.

The problem

Every business runs on answers. Which prep center are we using now? What's the return policy on that supplier? How do we price a job with heavy slash? What did we tell that customer last spring? Is this brand still gated for us?

You answered each of those once. Then you answered them again. If you have a VA or a team, you've answered some of them dozens of times. A small business owner on Reddit put it better than I can: "Spent a whole day training someone yesterday. Today they asked me the exact same questions." (thread)

AI made this worse before it made it better, because now there are two of you asking. Your team asks you, and unless your agent has your business context on hand, you re-explain the business to it too. One operator who runs AI for four or five client businesses said he was spending the first hour on every client "just explaining that client to Claude. And that hour wasn't part of what any of my clients were actually paying me for." He credits a handful of changes to his setup, starting with writing each client's context down once, and reports saving 128 hours in six weeks after subtracting the time he spent fixing what it gave him. (post) That's his own count, not an audit, but the first-hour problem will sound familiar to anyone running an agent.

Answering a question the first time is cheap. Answering it the fortieth time is where the cost is.

The obvious fix, "write it all down," has a long track record of failure. People build a wiki, a Notion, a folder of SOPs, and six months later it's a graveyard. One person on X laid out the math after deleting a 340-note system in month three: every note needs four decisions from you forever (capture it, organize it, link it, update it when something changes). "I was spending more hours maintaining my own memory than the thing was saving me... I built a library and made myself the librarian." (post)

Most owners have plenty of places to write things down. The systems die when keeping them current costs more than they visibly save, and then the answers go back to living in your head.

Fixing that takes four jobs, and I'll use them through the whole series:

1. Capture. The answer gets written down the first time it's given.
2. Shape. It gets filed as an answer someone can use, linked back to where it came from.
3. Find. Whoever asks later (you, a VA, your agent) gets it, even worded differently.
4. Trust. You can tell which answer is current, who confirmed it, and when.

Most setups only do the first one.

Why the five-minute versions fail

My feed is full of easy answers to this problem right now, and I get why. They demo well. On day one, every one of them works, and that's the trap: they work long enough for you to start trusting them, and then they decay without telling you. Three patterns keep coming up, and the folder is the big one.

"Just keep everything in a markdown folder"

The pitch: make a folder or a GitHub repo of markdown files, point your agent at it, and let the agent write to it as it learns. One popular post this week laid out how a company spins up a new specialized agent in about five minutes. Step four: "Give it read/write access to the Second Brain (a GitHub repo of markdown files)." (post) To be fair to him, that post is about plugging a new agent into a brain his team already built, and he calls the brain "the single most impactful thing we've built." The five minutes is the agent. The brain behind it took a lot longer, and that's the part people skip when they copy the setup. A lot of these folders trace back to an idea file Andrej Karpathy published in April for a personal wiki the AI maintains.

I'm not anti-markdown. My own brain is markdown underneath, and that's what saved invoice day last week: when the clever parts broke, my agent could still open the plain files. I'd store business knowledge in markdown every time. The trouble starts when a bare folder, with nothing around it, is the whole plan. A bare folder handles part of capture and none of the other three jobs. Here's where that breaks for a business.

It outgrows plain file search fast. Karpathy is upfront about this in his own write-up. His index-file approach "works surprisingly well at moderate scale (~100 sources, ~hundreds of pages)," and "as the wiki grows you want proper search." Hundreds of pages comes quickly once every customer, supplier, job, and decision gets one. Just the markdown files under my brain run about six thousand files and close to eight million words, several times more than even a million-token model can hold at once. Past a certain size the agent can't read the folder. It can only search it, and plain file search looks for the words you typed. Ask about "the supplier that kept shorting us" and it can easily miss the file titled "March credit dispute." You can add better search to a folder (Karpathy points people to a local search tool for exactly that), but by then you're building a system, not keeping a folder.

A bare folder can't tell you which answer is current. When two files disagree, nothing in the folder says which one wins. Your agent goes with whatever it found first and says it with full confidence. A Hermes user put it well on X a couple weeks ago: when stale memory files don't get audited, "the agent argues from dead context." (post) Someone on Hacker News gave the business version: context "that's right on Monday is quietly wrong by Friday, and nobody notices until a decision gets made on it." (thread) For a reseller that's last quarter's supplier terms, an old ungating rule, or a repricer floor you already changed.

If nobody reviews what the agent writes, its mistakes become your facts. In Karpathy's pattern the LLM "writes and maintains all of it." He also builds in periodic health checks for contradictions and stale claims, and for business use he suggests "humans in the loop reviewing updates." The five-minute copies tend to keep the first part and drop the second. Without review, every mistake the agent files once gets read back to you as fact, and so does anything wrong it picks up along the way: a supplier email, a product page, a customer message. One security paper posted in August shows how much damage a little bad memory does. In a benchmark experiment, researchers slipped plainly worded false statements into an agent's memory, no hacking and no hidden instructions, just wrong facts. At 1.2 percent of the memory, accuracy fell from 85 percent to 30 percent, and a screening pipeline built to catch injected instructions let all 360 false statements through. A wrong fact doesn't look like an attack. (paper) That's one lab's test, not a measurement of your folder, but OWASP, the nonprofit behind the security checklists most software teams work from, now ranks memory and context poisoning among its top ten risks for AI agents. For most of us the threat won't be an attacker. It'll be your own agent filing a wrong number on a Tuesday, and you finding out in March.

Whoever gets the folder gets everything in it. One shared repo means every agent you connect and every VA with access sees every customer, every margin, and every login someone pasted in "just for now." That last part happens more than people think. GitGuardian reported finding hardcoded passwords or keys in 32.2 percent of the internal repositories it analyzed, against 5.6 percent of public ones. (report) Private doesn't mean safe. Under the five-minute post, the first serious question came from someone setting this up for a small consulting firm: one repo for everything, or separate ones for confidential knowledge? That's the right question. You can split folders and lock them down, but somebody has to design that, and the five-minute version doesn't.

It doesn't know about the parts of your business that move. A food-company owner who runs his business with Claude Code as the operator made the point on Reddit: the "plain folder" promise "breaks down once you have real state, orders, inventory, a calendar. At that point the system needs actual data connections, not just instructions in a repo." (thread)

Nobody finds out when it stops working. A bare folder never throws an error. When search misses, or a file goes stale, or an agent overwrites a good page with a worse one, the folder looks exactly the same. You find out when somebody acts on the wrong answer: your VA follows a rule you killed in July, a customer gets last year's price, or your agent reorders from the supplier you dropped. And because the answer arrives sounding confident, it sounds exactly like the right one.

None of this makes a folder useless. It's a fine start for one person with a few hundred pages they write and check themselves, nothing time-sensitive, and nothing secret in it. The starter kit in the paid section of this issue is a folder, on purpose. The difference is what's around it: a person confirms every answer, old answers get moved out of the way when they're replaced, the agent is told exactly where to look, and you test it. That's a folder with the trust job bolted on, plus a clear sign for when to outgrow it.

"Just turn on memory in ChatGPT or Claude"

Turn it on. It's free and it helps. Just don't treat it as your business's memory. Both apps let you review and edit what they remember, and Claude even lets you export it. But it's built to remember what helps the next chat, not to be complete. OpenAI's own help page says memory "does not retain every detail from every conversation" and that "ChatGPT decides which available information is relevant to a response." (source) It also lives inside one person's account in one app. Your VA can't search it, and your other tools can't read it. That makes it a good personal assistant feature and a poor record of how your business runs.

"Just dump it all in and let the AI sort it out"

Record a Loom, export your Slack, upload the PDFs, and call it done. This came up in our Discord last week, and here's what I said: it doesn't really work, because the model reads that transcript a little differently every time it runs, and you'll never be sure what shape the answer comes back in. For simple things it may never bite you. For anything with real steps it's a nightmare. Keep the raw material, because it's your evidence. But the usable answer has to be pulled out of it, linked back to it, and checked by somebody who knows.

How to identify it

You're paying the answer tax if any of these are true:

• The same question gets three different answers. Ask your VA, your partner, and your agent what your rule is for damaged inbound. Three versions means you don't have an answer, you have three opinions.
• The honest answer to "where's that written down?" is "ask me." You're the knowledge base, and you don't take vacations.
• You paste the same background into your agent every week. Pricing rules, buy criteria, who your customers are. If you carry the context into every session, you're filling in for a memory that isn't there.
• Old answers beat new ones, or nobody can tell which is current.
• Your agent writes to your notes and nobody reads what it wrote. If you couldn't say what it added last week, you don't know what it believes.

A quick test: write down the last ten questions someone asked you, including your agent. Next to each, write where the answer lives. If most of that column says "my head," keep reading.

How to fix it

Do all four jobs, not just capture.

Capture works best when it happens without you doing the writing: meeting notes, a Slack reply, a chat with your agent, an email to a supplier.

Shape is the job almost everybody skips. A company with real scale learned this the hard way. Cerebras built an internal Q&A tool that now gets asked over 15,000 questions a day, and their CEO wrote that embedding raw Slack threads failed in their system: "'sounds good, thanks' sits close to almost every query." What worked was having a model rewrite each thread into "the question someone would search for. And the resolution." Accuracy "jumped significantly." (post) The chat log stays as evidence. The shaped answer is what gets found.

Find is a ladder, which I laid out in our Discord last week. Exact-word search finds direct matches. Search by meaning finds the answer when you use different words. Following links between pages answers the harder questions, because a hit on the customer also pulls in the job, the bid, and the person who quoted it.

Trust means every answer carries who confirmed it and when, and the current, owner-confirmed answer wins. Newer alone isn't enough: a fresh customer email shouldn't overrule a policy you set. When two answers conflict, the system should flag it for you rather than quietly pick one. That sounds like a detail and isn't. Even products built for this trip on it. An open issue on Mem0's open-source version reports a three-month-old fact outranking the update that replaced it (issue). The system I run has had a bug where a job reported success while doing nothing (example, since fixed). A brain that confidently quotes last quarter's supplier price is worse than no brain, because you'll believe it.

Saul, an e-commerce operator who runs a team, described a clean version of the capture-and-shape habit on X: if someone asks a question in Slack that "can't be answered in a sentence, that then turns into a playbook." A skill collects the question and answer, takes screenshots, and files it where the team can see it. His goal is hundreds of them, and he says the team at The BuyBox has started doing the same. (post)

What I run, and what else is out there

I run GBrain, the open-source memory system Garry Tan at Y Combinator built. My agent checks it before answering anything where history matters. Every person I talk to gets a page and a timeline. Every customer, job, bid, meeting, and decision gets filed and linked. Right now it holds a little under fifteen thousand pages and about forty-nine thousand links between them. Over the last 30 days my agent went to it in about 37 percent of my working sessions, and that undercounts, because it leaves out the scheduled jobs that run while I sleep.

It's the most capable thing I've used, and I'll keep saying the other half: it's fussy. It wants care and feeding every week, and an upgrade broke it on invoice day at month-end, which I wrote about on Friday.

GBrain isn't the only way to do this. I teach it because it's what I run, and I won't pretend to teach tools I haven't lived with. Here's the rest of the field. The facts come from each vendor's own pages. The opinions are mine, and I haven't tested any of these myself:

• Memory built into the tool you already use. Claude and ChatGPT both remember things across chats and have Projects that hold files. Hermes has built-in memory plus search across past sessions, and Claude Code, Codex, and OpenClaw keep memory in plain text files. No extra cost, minutes to start, and usually limited to that one tool.
• Notes apps. Obsidian is free and keeps everything as plain files on your machine, so any agent can read it. Notion is a cloud workspace with a connector agents can use; paid plans start at $10 a seat, and the full AI features start on the $20 Business plan. I've told members Obsidian is a good place to start before something like GBrain.
• Memory services you plug into your agent. Honcho, Mem0, and Supermemory all have documented Hermes integrations, and most connect to Claude Code and other tools too. Mem0 and Supermemory have free tiers with paid plans from $19 a month; Honcho charges by usage. Zep is aimed at developers, and Letta is its own agent app with memory built in. For Hermes users who don't want the fuss, Honcho is the one I've suggested looking at.
• Team search tools. Glean is built for big companies, with seat pricing through sales. Dust is priced per seat for small teams.

They differ in how much of the shaping and trust work they do for you, where your data lives, and what happens when you want to leave. We'll get into those differences part by part.

Where this goes for our members

The use cases I'm building this series around come straight out of our Discord:

• Buy and pass decisions. A member asked back in August how an agent would recall hundreds of lead reviews as the pile grows. The numbers belong in your database. The reasoning ("passed because the brand restricts, bought because the price history held through Q4") belongs somewhere searchable.
• Your database stays your database. A few of you have built serious SQLite systems for orders, inventory, and P&L. Keep your live numbers there. The brain holds what the columns mean, the rules behind the repricer floors, and why you changed them.
• Your company chat becomes your SOPs. At least one member is pulling his whole company Discord into a searchable history of how they do things. That's the Cerebras lesson at small-business scale.
• The newsletters and courses you pay for. I keep the paid newsletters and videos I subscribe to in my brain, strictly for my own use and never shared, so I can ask "what does this person's framework say about this item at this buy cost?" and get an answer with the source attached.
• Every supplier, prep center, and customer gets a page. One place for the history, the rules, and the last thing anybody said.

Next up in the series is the one I see people get wrong most: which answers belong in a skill, which belong in a database, and which belong in a brain.

The playbook: the answer-it-once starter kit

This works whether or not you ever install GBrain. Do steps 1 through 4 this week with whatever you have. Step 5 is the GBrain path for when you're ready.

Step 1: Find your top repeated questions

Your agent can do the counting. Before you start, decide which sources it may read, give it read-only access, and check which AI provider will see that content (if a source has customer or employee data you can't send to that provider, leave it out). Then paste this into your harness:

I want to find the questions I answer over and over in my business. Read only from the sources I've approved: [list them, for example my sent email, our team Slack, my VA's messages, our past sessions]. Do not send, delete, or change anything in any source, and skip anything that looks like a password, key, or login. Look back 90 days. Find questions that came up more than once, even worded differently, and group them by meaning. For each group give me: the question in plain words, how many times you saw it, who asked (role only, no names), the best answer I gave with a link to where I gave it, where that answer lives now ("nowhere" is a fine answer), and whether my answers were consistent. Rank by count, top 20. Then tell me exactly what you could and couldn't read: which sources, which date ranges, and anything you hit a limit on, so I know whether the counts are complete or partial. Do not write anything to my files yet.

Look for two things in the output: the high-count questions, and the ones marked inconsistent. The inconsistent ones are where money leaks. Treat the counts as "at least this many," unless the coverage report says it read everything.

Step 2: Write the answer card

Every answer gets the same small shape. This is the shape job from the free section, and it's what makes the trust job possible. The example below is made up; fill in your own.

---
question: What is our rule for damaged inbound units?
status: current
confirmed_by: Justin
last_confirmed: 2026-10-04
review_by: 2027-01-04
replaces: archive/damaged-inbound-2025.md
sources:
  - https://mail.example.com/thread/abc123
  - https://discord.com/channels/your-server/your-channel/123456
---

**Answer:** One or two sentences. The thing you'd say out loud.

**Why:** The reason, in one or two lines. An agent follows a rule much
better when it knows the reason.

**Steps (if any):** Numbered, short.

**Exceptions:** The cases where the answer changes.

A few rules make the card do its job:

• last_confirmed is the day you actually checked it, not the day it was typed.
• Sources are real links to the original email, message, or file, so anyone can check what was actually said. Keep the originals. The card is the answer; the source is the evidence.
• When an answer changes, write a new card, set the old one's status to replaced, and move it into an archive/ subfolder. Leave replaces empty on a brand-new card. Metadata alone won't stop an agent from finding the old card. Moving it out of the main folder will.

Step 3: Put the cards where your harness looks

Use the slots your tool already has, not a parallel folder it never reads (we covered why in the prompting issue).

Then tell your agent where the folder is. Add one short instruction to whatever file your harness always loads (AGENTS.md, CLAUDE.md, or your Hermes or OpenClaw memory): the folder's full path, "check it before answering questions about how we do things," "only use cards marked current and cite the card you used," and "if two cards conflict, tell me instead of picking one." Then open a fresh session and ask one of your questions without mentioning the folder. If it doesn't find the card on its own, the folder isn't wired in yet.

Start with your top ten from step 1. That's an afternoon, not a weekend.

Step 4: The known-answer test

Write ten questions where you know the right answer. Make two of them tricky on purpose:

• one where the answer changed, so there's an archived card with the old answer (the right response is the new one)
• one your cards don't cover at all (the right response is "I don't know," not a guess)

Word a couple of the others differently than the card does. Ask your agent each one, cold, in a fresh session. Count how many it gets right without help.

Write the number down. Rerun the ten every time you change your setup, switch models, or upgrade anything. If the number drops, something broke, even if every command says it succeeded. This is the cheapest insurance in the whole series, and it's how I'd have caught my invoice-day problem a day earlier.

Step 5: The GBrain path (when you're ready)

Graduate when the folder starts failing you. The signs: you have more than a few hundred cards, you're asking questions that cross several cards ("everything about this supplier, including the jobs we lost to them"), or you want capture to happen without you writing every card.

What to know before you start, from GBrain's own README and my experience:

• Install from GitHub only. The README warns that the npm package named gbrain is an unrelated project.
• It can start without any AI keys. Keyword search works with no model provider. Search by meaning needs an embedding provider, and synthesized answers need a chat model. Those are where the costs start.
• Your pages stay markdown, but the database matters too. Pages sync into a database that also holds history and links. Back up the database, not just the files. Your answer cards from step 2 import as pages, so nothing from this week is wasted.
• It plugs into your harness as an MCP server. The README covers Claude Code and Codex directly, plus always-on setups for Hermes and OpenClaw.
• Its own docs say "Install in 30 minutes." My honest read for a non-developer: an afternoon for the local version, a weekend or more for an always-on server.
• Budget for upkeep. I run a separate agent profile whose only job is keeping the brain healthy: a full health check every couple of days, content quality, upgrades. Every so often I ask it one question: "are we running gbrain right?" A later part of this series is entirely about that.

Then import your cards and rerun the known-answer test, plus a few of the cross-card questions that made you want to switch. If those get better, keep going. If they don't, the folder may still be enough for now, and you just saved yourself the upkeep.

What not to do

• Don't dump raw transcripts and call it done. Cerebras found in its own system that the chatter drowns the answers. Shape first, and keep the originals as evidence.
• Don't let the agent build a structure you can't explain. One owner on Reddit stopped his system after a few weeks, not because it broke, but because "the architecture is not clear to me anymore" (thread). If you can't say where a new answer goes, simplify.
• Don't keep live numbers in the brain. Inventory, prices, and balances stay in the database or spreadsheet that owns them. The brain holds what they mean and why they changed.
• Don't skip the dates. An answer without a confirmed date is an answer you can't trust in a year.

Steal this

Tonight, run the step 1 prompt and look at the top three questions. Write one answer card for each and wire the folder in. Tomorrow, ask your agent those three questions in a fresh session and see if it finds them. That's answering it once, three times over.

Hit reply and tell me the most repeated question in your business. I read every one, and the best ones are going into this series.