Your AI employees need a handbook

I've seen people try Claude or ChatGPT, get mediocre answers, and conclude AI is overhyped. But the power of agents doing real work for every employee comes from the agent knowing your company, your team, your processes.

If you use the vanilla version and expect it to be mind-blowing, you're testing the wrong thing. Exceptional performance comes from onboarding it properly.

Every agent session is like a new hire

An AI agent is like a bright university graduate who has knowledge of everything at the average level of the internet, or in some cases above. But it does not have any understanding of your particular company, your organization, your product, your codebase. Just as if you were hiring a human graduate.

When humans join a company, there is typically an elaborate process to onboard them. There are onboarding sessions, employee manuals, processes to give them access to company systems. There are meetings scheduled with key stakeholders. It usually takes weeks for a person to get semi-productive, and up to a year to reach their peak.

You have to do the same onboarding for agents.

Onboarding ten times a day is expensive

But there's a catch: agents don't remember. Every time you start a new session (which you do tens of times a day), all of that knowledge walks out the door. If you had to onboard an intern 10 times a day, it would be impossible to be productive. You would fire them.

Before solving this, I used agents maybe 10 to 20 times less for my actual work at Pactum: for understanding things, for collecting input for decisions, for putting ideas into action.

The barrier to entry was too high. Every session started with me copy-pasting links, looking up context, re-explaining things so Claude or ChatGPT would even understand what I was talking about. If it was important, I'd spend several minutes assembling context manually before I would even ask my question. Often I didn't bother.

This is what it looked like: every single session, I'd paste in a 12,000-word wall of text before I could even ask my question.

It was ugly, but it worked. That single block of text (company vision, org chart, strategy, key people) turned generic AI into something that understood my world. And that realization pointed to the solution.

A company handbook for agents

The analogy points to the answer: a company handbook.

Companies that have invested in onboarding have usually built some form of this. It's often a knowledge base or wiki that contains the most important information, structured so it's easy to get started. No need to go deep. The basics are enough: what is this company, who are our customers, what's the vision, what's the org structure, where do I find things.

Give your agents access to this handbook every time they run, and they can jump straight into useful work:

You get answers grounded in how your company works, without spending minutes assembling context first.

Here's roughly what it looks like:

company-handbook/
  _index.md          (start here)
  company/           (strategy, goals, values)
  people/            (org structure, key roles)
  product/           (what we build, how it works)
  technology/        (architecture, key systems)
  operations/        (processes, tools, access)

At Pactum, we built this as a simple Markdown-based wiki. It doesn't even contain much. Since we hadn't historically had a great central handbook, most entries are a link to an original document and a brief summary of what you'll find there. The skill also tells Claude that this is a snapshot, so it should look up the original source whenever it needs the full or most recent version.

The minimum version is one page: a single Markdown file that links to the most important sources. Those links typically point to places the company already stores its documents: Google Drive, Confluence, GitHub. Since agents have read access to those systems, a link is enough for them to fetch the full version when needed.

Building the handbook as a minimal index rather than a polished document helps you get started fast, and requires no change in human behavior. You don't need everyone to keep their section fresh. It doesn't matter to an agent whether it reads a Markdown file or fetches a Confluence page, as long as the content is there and discoverable. For a human that extra click is annoying; for an agent it's two seconds.

You might be wondering whether you need a retrieval pipeline (RAG) for this. You probably don't. Modern agents browse and look things up proactively and iteratively, much like a human would. The agent reads the index, follows links to the right pages, and pulls in what it needs. It's a much simpler solution than building an external retrieval system, and empirically it works well enough.

Start with one page

The best part is, most companies already have something like this for humans. It might be a Notion workspace, a Confluence space, an internal wiki, or even a shared Google Drive folder. You can build this in any tool. The key requirement is that agents have access to it.

GitLab's handbook is an often-cited standard for public company handbooks. It's comprehensive, well-indexed, and covers everything from strategy to engineering practices.

But you don't need anything that elaborate. Start with one page of links to your most important sources in every function, and you'll already see a difference.

I started with a personal version for my own use. Later I discovered another leader at Pactum had independently built something similar for themselves. When I realized this was already happening in several places, and created lots of value, we centralized it into a shared company handbook for agents.

If people in your company are already using AI agents, some of them are probably solving this problem on their own right now, and the rest are missing out on a lot.