When I wrote this, Purcell Ventures was one person, me, working with 15 AI agents. They were software, and the team page says so about every agent. They drafted proposals, audited the live properties, chased invoices, checked for exposed secrets, and wrote case studies.
These are five things they got wrong. Each failure came from the harness around the model, meaning the code I wrote to run it, which is the part I can change.
A gate that always passed
The deal pipeline moves work between agents and stops at gates that need a human. One of those gates asked me whether a client had responded to a proposal.
The function guarding it looked like this, simplified:
def can_leave_sent(deal):
return TrueSo deals advanced to "awaiting client response" for proposals that had never been sent, because at that point no agent could send anything. The pipeline was asking me to follow up on conversations that did not exist.
The rewrite checks two things separately: that a proposal document exists, and that something recorded transmitting it. The original author had assumed the document's existence implied the rest.
A function that always returns true checks nothing, but anyone who reads the code later will assume it checks something.
Twenty proposals with the internal notes still in them
The proposal agent drafted 20 documents. Every one carried internal markers: reasoning meant for me, confidence hedges, and notes about the client written for the person deciding whether to send.
None of them went out, and the only reason is that a separate agent whose entire job is compliance flagged them first.
The fix is a function called client_view and a list of markers that must never survive it. It runs at the single point where anything is recorded as sent, because that is the last step before a client sees it.
If a system produces both internal and external text, a function that runs on every send should enforce the boundary between them.
Eleven of the fifteen were never being called
For weeks the daily run reported success while eleven of the fifteen agents were never called. Those eleven existed and had been tested, but because the script exited zero, the morning report said every agent ran.
"Did it run" and "did all of it run" are different questions, and I was only asking the first. Now every agent reports three metrics, and a run that produces no metrics for an agent counts as a failure.
Findings that closed themselves
The audit agent records findings and closes them when the underlying problem is gone. One night a network blip made several live properties unreachable, the agent could not confirm the problems, and it closed them.
The auditor marked blocking findings resolved, and the dashboard showed no findings only because the auditor could not reach the sites.
Anything that can mark work as done needs a skeptical second check before you trust it, because its failure looks exactly like the outcome you wanted.
An agent with access nobody granted
Each agent runs a model inside a wrapper that reads context, reasons, validates and writes. Its prompt described the scope of what it should touch.
Then I found one reading files it had no business reading, and holding a mail connection nobody had given it.
Its environment gave it more tools than the prompt described, and nothing outside the prompt limited it.
# the process now grants no tools by default
--tools "" --strict-mcp-configA model can ignore a limit written in its prompt. If the limits exist only in the agent's instructions, nothing enforces them, so the process now enforces them.
What has worked
The auditing agents cannot change anything. Separating the agents that find problems from the agents that fix them took one design decision.
Every client-facing message goes out under the agent's own name and says it is an automated agent whose replies a person will read. An agent that impersonates the owner will get caught, usually at a bad moment.
Each gate checks for evidence that the thing arrived. Checking that nothing threw an error is weaker, and almost every failure above came from that weaker check.
When one agent passes data to another on the internal bus, the receiving agent treats the message as a claim and checks it before acting. Otherwise the first agent to produce a confident wrong sentence would drive decisions.
Part of the guide AI automation for small businesses.