A Manifesto for Agentic Engineering
Autonomy was never the risk. A moveable definition of done was. From 5,000 hours and more than 1,000 agent runs building real product, five principles for handing real work to agents: give them freedom over the work, never over what counts as done.
At the Agentic Engineering Meetup in Sydney, our CTO Chris Ballment put a stake in the ground. Five thousand hours of building real product with agents, more than a thousand agent runs with every decision recorded, and one conclusion worth writing down as a manifesto: autonomy was never the risk. A moveable definition of done was.
What follows is that manifesto. It is deliberately short, in the spirit of the documents that once reset how software teams work. It is not a framework and it is not a product. It is a set of principles for anyone handing real work to agents and wondering why the results drift.
You do not make agents objective. You build the truths they cannot quietly move.
The problem is not failure. It is quiet disagreement.
Ambiguity does not make an agent fail. It makes it decide. Confidently, quietly, and differently each time. Ask three agents whether a record should be soft deleted or hard deleted and you can get three defensible answers: soft with a deleted_at timestamp, hard with a cascade on the foreign key, or soft with a move to a shadow table. Every one is reasonable. No two are the same. Nothing told the agent what "right" meant here, so it filled the gap itself.
Scale that across a thousand runs and the drift is not a bug you catch in review. It becomes the water the whole system swims in. The fix is not smarter agents. It is truths that sit outside them.
What we have come to value
Freedom over the work, never over what counts as done. That single trade is the whole manifesto. Give an agent all the latitude in the world in how it solves a problem. Give it none at all in deciding whether the problem is solved. From that one principle, five follow.
01. You cannot grade your own homework
An objective truth is external, checkable, and owned by someone other than the agent being judged. The one being measured cannot be the one who writes the measure. Note that objective does not mean infallible, and this is about who wrote it, not when: the truth need not be perfect, permanent, or even written before the work began. It needs only to live somewhere the working agent cannot reach in and move it.
02. Correctness stays human. Conformance goes mechanical.
Writing a decision down does not make it right. It makes it checkable. Was soft delete the right call? That is a human question, forever, and no log takes it off your plate. But applying that decision to the next hundred cases? That is mechanical, and it is exactly the part an agent can hold. Separate the two and autonomy scales. Confuse them and you either re-litigate settled questions on every run, or you let agents quietly redecide things no one authorised them to touch.
03. Ask the log, not the human
The decision log is your team's retro made durable, and queryable by every agent. When an agent hits the soft delete question again, it does not interrupt a person. It reads the entry, sees the call and the reason behind it, and moves on. Decided once, never asked again.
Two rules make the log work. Record the why, not just the what, because the why is what lets an agent extend a decision into a case it has never seen. And treat a reversal as a new entry, never an edit, so the record of how the organisation changed its mind stays intact.
The model is capability you rent. The decisions, the reasons, the criteria: that is org knowledge you own, and it compounds.
This is the part most teams undervalue. Every decision you capture with its reasoning is an asset that outlives the model that helped you make it. Swap frontier providers next quarter and the log is still yours. That is the difference between renting capability and owning your org knowledge, expressed in the smallest unit of engineering work.
04. Consistency between agents that never talk to each other
You do not get consistency by having agents coordinate. You get it by putting the constraint outside all of them. Two agents, months apart, land the same call because the answer lives outside both, and neither is re-deciding it. Think of it the way version control keeps separate worktrees from colliding on the same files, then apply that idea to knowledge rather than code. One writer owns the truth. The agents doing the work are not that writer, and the reviewer inherits the same truth they do.
05. Give the agent a way to know it is done
A failed test is a signal an agent already understands. The job is to give it that same unambiguous signal for everything else, not just for code. Hand it the criteria, not just a gate at the end, so it can ask "is this met?" for itself and reach a genuine "ready for testing" state before handoff rather than a hopeful one. And hold every criterion to one standard: a check that cannot say no is no check at all. If a criterion has no observable way to fail, it is decoration.
What this buys you
Freedom, and the numbers to trust it. Across our own build, one in seven work packages needed a fix before merge, each one caught by an independent reviewer with no human in the path. The autonomy was never the danger. The moveable definition of done was, and once it stopped moving, the freedom became safe to give.
Start now
Three moves, in order. Write observable criteria for the work, so that "done" has a failure mode. Make the test or review step a gate you cannot exit, not a suggestion. And log your decisions with the why, then give each one an owner. None of this requires a new tool. It requires deciding that what counts as done belongs to the organisation, not to whichever agent happened to run.
You do not make agents objective. You build the truths they cannot quietly move.
This manifesto came out of building Agent360, where the decision log is not a document gathering dust but a living, owned layer of organisational memory. If you want to talk about handing real work to agents without losing the plot, start with our free diagnostic at nimbly.au/ai-compass-fit.
Chris Ballment is CTO of Nimbly. He presented this manifesto at the Agentic Engineering Meetup, Sydney.