I spent a week teaching a bot. Then I ran out of tokens.
I spent most of my first week with Grok Bot teaching it how to do my work at Gravitate. I went through the tasks that were taking up my time, particularly the ones that happened entirely on a computer, and started showing the bot how to handle them.
By the end of the week, I'd used practically my entire token allocation. I'd spent all those tokens teaching the bot, and now I couldn't use it to do the work I'd trained it for.
The obvious reaction is that I'd spent too much on training. But using any worker costs money. If I hire somebody and spend a week training them, I still have to pay them to show up the following week.
What bothered me was something else.
Teaching was only half the work
Working with Grok Bot felt surprisingly similar to training a new employee.
I'd explain what I wanted done, the bot would attempt it, and I'd check the result. Sometimes it would get things right immediately. Other times it would confidently complete a task incorrectly because something important was missing from my instructions.
I quickly discovered two bottlenecks.
The first was explaining myself. I knew how I wanted a task completed, but turning that knowledge into instructions was much harder than I expected. Things I understood instinctively still had to be explained to the bot.
The second was verifying the result. A bot telling me it understood didn't mean much. I needed to see the work, compare it with what I expected, identify mistakes, and keep correcting them until I was satisfied.
Both steps required my time and attention.
And this was where most of my first week's tokens went. Not into getting useful work done, but into explaining what useful work looked like and checking whether the bot could actually do it.
What happens when I change bots?
When I started looking at other agents, I ran into a problem I hadn't really considered.
I'd already spent a week teaching one bot how I worked. What would happen if I wanted to give those same tasks to a different bot?
I could explain everything again, watch the new bot attempt each task, and correct its mistakes.
I could also ask my existing bot to help train the new one. That might save some explanation, but I'd still have to establish whether the new bot could perform those tasks correctly.
And the problem wasn't limited to switching providers. Even with the same provider, the particular agent I'd spent time teaching had accumulated context, corrections, and preferences that weren't necessarily available to another agent.
I realized I was treating each bot as the place where the knowledge lived.
That's not how I'd want to run a company with human employees.
If I spend weeks training someone, I want the company to come away with more than one knowledgeable employee. I want the procedures documented, examples preserved, mistakes understood, and expectations clear enough that I can use those materials to train somebody else.
The same principle should apply to bots.
The instructions aren't enough
There's another distinction I hadn't appreciated at first.
Suppose I've taught a bot how to reply to certain customer requests. It took several rounds of corrections, but eventually the replies looked the way I wanted.
I could save the final instructions and give them to another bot.
But that doesn't establish that the second bot can do the job.
The first bot might have needed several examples or additional context that never made it into the final instructions. The second bot might interpret something differently. It might produce a convincing answer while missing a detail I consider essential.
I'd still have to check its work.
So there are really two things worth preserving: what I taught the bot, and how I determined whether it had learned.
The first can be a collection of instructions, examples, and demonstrations. The second requires tests with observable criteria for success.
If I keep both, I can give another bot the same material and see whether it meets the same standard. I don't have to rely entirely on remembering how I trained the previous one.
That doesn't guarantee the next bot will perform as well. It gives me a way to find out without inventing the evaluation again.
Separating the knowledge from the worker
This is what led me to start building LIT.
I found that recording my screen while explaining what I'm doing was a much more natural way to capture how I work than trying to reconstruct every step in a written prompt.
When I demonstrate a workflow, I can explain why I'm making a decision, what I'm looking at, and what I expect to happen. Sometimes I discover an exception or change my mind halfway through. Those moments are part of what I'm trying to teach.
LIT lets me record my screen and voice together and send the recording and transcript to a bot.
LIT also handles the verification. It creates chapters from lesson transcripts and generates tests for each lesson. Bots submit their attempts, and LIT grades them against a fixed set of checks, with 90% required to pass.
The objective isn't to make any particular bot indispensable.
It's to preserve enough of my knowledge, preferences, and expectations that I can teach another one without reconstructing everything from memory.
I still have to pay whichever bot actually does the work. That's perfectly reasonable.
What I don't want is to pay the cost of teaching the same work from scratch every time I change who or what performs it.
A question for your own setup
Think about the last workflow you taught an agent. If your tokens ran out tomorrow, or you wanted to try a different agent next week, what would you still have? Would you have the instructions, examples, corrections, and a way to verify that another bot could do the same job? Or would you have to explain it again and figure out all over again whether the new one could do it correctly?
The bots can do the work. The know-how, and the way you check it, are worth keeping somewhere you own.