Suppose you ask an AI agent to fix a customer import for your ERP. The next morning, it says, "All tests passed." You still don't know which database it used, whether it changed the duplicate-matching rules, or where it tried to send data. Would that be enough evidence to approve the real import?
That question is why I'm interested in harness engineering: designing the tools and controls around an AI model so it can work within a defined scope and leave evidence people can review. Model choice matters. Before extending a run, though, we need to know what the agent can reach and when it must stop.
Google's Practical Harness Engineering with Google Antigravity codelab connects models with their surrounding tools and discusses sandboxes and hooks. I'll use the following hypothetical ERP task to explain how a team could put those ideas to work.
The model reasons; the surrounding system governs action
A harness connects a model to tools and manages its working loop. It handles file requests, program execution, state, and results returned to the model. Designing it also means deciding permissions, verification, and stopping conditions.
For our customer import, I'd define the deliverable as a corrected importer and a dry-run report, using synthetic data and a disposable test database. Completion means a reviewable list of proposed creations, updates, and errors. Writing live records requires a separate decision.
"Make the import succeed" leaves room to reinterpret the task, perhaps changing source data until it passes or seeking production access. Completion criteria should cover the permitted route, too.
Written instructions and access boundaries do different jobs
I'd use AGENTS.md as a short project map pointing to the rules and verification steps. A skill would cover a specific task, such as duplicate matching. Antigravity documents skills as packages containing SKILL.md, with detailed instructions loaded when relevant. Agent skills documentation
Writing "don't touch production" doesn't remove production access. In this example, I'd keep production credentials out of the working environment and restrict database tools to the designated test database.
| Layer | What it establishes | What still needs checking |
|---|---|---|
| Instructions | AGENTS.md points to requirements; a skill explains matching | Did the agent apply the right rules? |
| Permissions and sandbox | Access limited to approved files and test database | Are out-of-scope requests actually blocked? |
| Tool gates | Stop out-of-scope calls before execution | Are all calling paths and failure cases covered? |
| Acceptance | A person reviews results and business rules | What does the evidence establish about correctness? |
Antigravity's terminal sandbox documentation describes OS-level isolation of shell commands, controlling file and network access. Behavior varies with version, operating system, and account. Check the active configuration before adopting an example. Terminal sandbox documentation
Here, I'd test that an out-of-scope dummy secret and a disallowed test endpoint are inaccessible. Any separate API tool needs its own permission check; terminal restrictions don't establish every tool's boundaries.
Allow, ask, or deny
A hook runs additional logic at a defined event. Antigravity's PreToolUse hook runs before a tool executes and can return a decision governing that call. Hooks documentation
I'd allow reading synthetic data and testing in the disposable database, require review for new connection destinations, and deny production access. A command invoking another script also requires examining what that script will do. A familiar command name is insufficient.
The codelab proposes an AI classifier for ambiguous requests. English codelab I'd use one inside established boundaries: classifiers can misread context, and instructions embedded in inspected files can try to influence their judgment.
For this task, a timeout, unreadable response, or insufficient context should stop execution or trigger human review. This is failing closed. Test those failures as well as successful responses. The agent shouldn't be able to modify the policy or gate controlling its own work.
A review request should identify the action, target database or endpoint, affected data, and requested duration. Approval should cover that action; changed commands or files require another check.
A dry run must show more than "passed"
Here, dry run means reading data and reporting intended effects without writing to production. Test writes belong in a disposable database. A program called "dry run" might still send email, call external services, or modify files. Check those side effects.
I'd require proposed creations, updates, skips, and errors, each traceable to a source row and matching rule. Every input row needs an accounted-for status. If a tax identifier matches but the branch differs, the data owner should apply an agreed rule. The agent shouldn't merge records simply to reduce the error count.
Then repeat the import in the disposable database to check for duplicates, interrupt and restart it, and check that references still identify the right customers. If the tests contain no multibranch customers, passing doesn't settle that case. Tests establish the conditions they check; they don't guarantee business correctness.

Before the first unattended run
- Define a reviewable deliverable and the data and systems the agent may access.
- Grant test access only, then verify out-of-scope requests are blocked.
- Define allowed, reviewed, and prohibited actions, including gate failures.
- Set time or spending limits; stop for conflicting requirements or expanded access.
- Require a change report, test records, and unresolved questions before considering the next step.
My acceptance question for this import would be: "Where will each row go, which rule decides that, and who has confirmed the rule?" If the report can't answer, the next task is to gather evidence in the test environment. Permission to write live data should wait for a reviewable answer.