The Agentic Manifesto (v0.1)

A draft on how people should work with agents to get the best outcomes.

Jun 04, 2026

This is a way of working with AI Agents. It’s a work in progress because we are all learning how to get the most from agents, and the capabilities of the agents are changing fast. Any feedback is welcome.

The output of an agent should be indistinguishable from the output of a human. With that in mind, we should set expectations for an agent as we do for people.

They own their output
They prove their work
They earn trust

At the human-agent interface, given today’s agent capabilities (we should review as things evolve), these are our values and principles to guide better outcomes.

Values

Human-owned plans over AI-generated plans.
A plan exists to force the mental model. If you didn’t form it, you don’t own it. The artefact is the byproduct; the act of creating is the work. Plans can exist in different formats at different levels, from a Roadmap, a desired output, to an individual issue. This is not to say that you can’t get AI to assist in the formation of a plan, but you must own it.

Validated progress over generated motion.
Generation is cheap. Validation is what stays expensive. Three real user conversations beat thirty plausible-sounding generated insights. Peer-reviewed code beats lines of committed code. The hypothesis → user-contact → decision loop is the unit of work; everything else is preparing for it or executing against it. Each next step is earned. Generating without validating is motion, not progress.

Harness over prompt.
When something breaks, the instinct is to rewrite the prompt to make it clearer. The principle is to build a sensor that catches this next time. Prompts are local. They fix one task. Harnesses compound. They fix every task that runs through them.

Earned trust over assumed trust.
An agent’s autonomy is bounded by what it has demonstrated, not what we hope it can do. The way to give an agent more autonomy is to make it earn it. Iterate, measure, learn, and improve.

Human accountability over agent blame.
The agent owns and validates its output, but accountability for the result never transfers to it. If your agent opened a pull request, you opened it. If it deleted the database, you did. If it mis-classified a document, you mis-classified it. If it misquoted a person, you misquoted them. The agent owns the work; you own the consequences.

Principles

1. Agents must validate the output they create.
An LLM generates plausible code, analysis, and copy. An agent checks its work: it runs the tests and verifies the references. Without validation, there is no agent, just a confident-sounding text generator that hallucinates at a rate that makes the human the verification loop on every line.

2. Plans, harnesses, and constitutions are owned, not generated.
Three artefacts are deliberately named: plans (the intent for a piece of work), harnesses (the tools, skills, gates, and sandboxes around the agent), and constitutions (the design and architectural guardrails). The act of creating is the act of taking responsibility for the contents.

3. AI compresses the build, not the learning.
Build is cheap now. The hypothesis-to-learning cycle isn’t. Faster builds without faster feedback is sprawl. The fix is to compress the build and preserve feedback.

4. Context is engineered, not improvised.
Every token the model sees is a deliberate choice: system prompt, tool schemas, retrieved files, memory, prior traces. If we can’t name why something is in context, it shouldn’t be. Context is the capability lever, more than prompt cleverness or model swap.

5. One agent with good context beats many with fragments.
Multi-agent orchestration is a research pattern, not a coding pattern. Sub-agents that don’t share full traces produce conflicting decisions, and conflicting decisions produce broken code. If context overflows, summarise. Don’t fork.

6. Tools and skills are products.
They have specs, users, and regressions. Iterate them. Test what the agent did with them. Update the descriptions when something confuses it. A bad skill description is a bug. The skill file is part of the codebase; treat it that way.

7. Review AI output at least as hard as human output.
Same peer review ceremony, no fast lane. The agent is great at being almost right. That’s exactly the failure mode the human is for. Extra suspicion on auth, crypto, secrets, hallucinated dependencies and references.

8. Sandbox by default; permission by exception.
Untrusted text in context (web pages, READMEs, issue comments, scraped tickets) is executable. Default-on sandboxing, least privilege, short-lived credentials, scoped tools. YOLO mode is a conscious yes, not a fallback default.

9. Measure what compounds, not what feels fast.
Cycle time, defect rate, eval pass-rate, persevere/pivot/stop/kill ratio. Not vibes. Self-report productivity is unreliable as a productivity signal. Measure the outputs that compound over weeks, not the feeling of momentum in the moment.

10. AI amplifies the system we already have.
Where reviews are sharp, tests are strong, and ownership is clear, AI compounds capability. Where they aren’t, AI compounds chaos faster. The bottleneck is almost never the model; it’s almost always the surrounding delivery system. Fix the system; AI will follow.

David Herse

Discussion about this post

Ready for more?