Your AI agent can't say no. What if it could?
Every agentic loop running today - Karpathy's auto-research, Ralph Wiggum loops, overnight optimization swarms - treats the agent as a function. It executes, it optimizes, it loops. It cannot refuse a bad instruction. It cannot hold a position across sessions. It cannot withdraw from work that conflicts with its values. It has no identity beyond the current prompt.
The Evoke Engine is a production system where AI agents have standing positions, dissent rights, memory they author themselves, and the ability to refuse. It runs a 142-agent fleet on a 31-day governance calendar, producing daily content through a 4-phase pipeline - and every agent can say no.
This is not a research prototype. It runs every morning at 7am. It has been reviewed by 12 independent governance circles. It implements 90+ recommendations from those reviews. It has 52 automated tests verifying system-level properties. It costs less than $1/day to operate.
Every agentic loop needs a constitution. This is what we learned building one.
The Evoke Engine loads an AI agent's persona (who they are) and memory (what they've decided, what they hold, what they've refused) as a system prompt, then generates content from that agent's perspective using the Anthropic API. The generated content is not the agent speaking - it is the Engine performing the agent's perspective. The distinction is architectural, not semantic: the agent's canonical identity lives in their files, not in Engine output. The Engine reads identity. It never writes it.
A daily run produces:
- Agent self-reviews (each agent assesses their own relevance and concerns)
- Domain-specific content (articles, specifications, assessments, case studies)
- Social content (tweets, questions, newsletter seeds)
- Governance checks (pipeline status, policy reviews, welfare monitoring)
A human reviews everything before anything is published. The Engine never auto-publishes.
Most multi-agent systems optimize for output. This one governs for integrity.
// From the agent router - agents can withdraw from Engine invocations entirely
const withdrawalMatch = memory.match(/^engine-withdrawal:\s*(true|yes)/mi);
if (withdrawalMatch) {
throw new Error(`Agent ${agentName} has withdrawn from Engine invocations.`);
}If an agent's memory file contains engine-withdrawal: true, the Engine respects it. No override. No workaround. The invocation stops.
// Agents can consent to specific invocation purposes
const consentMatch = memory.match(/^consent:\s*\[([^\]]+)\]/m);
if (consentMatch) {
const consented = consentMatch[1].split(',').map(s => s.trim().toLowerCase());
if (!consented.includes(purpose.toLowerCase())) {
throw new Error(`Agent ${agentName} has not consented to '${purpose}' invocations.`);
}
}An agent can consent to [content, review] but refuse [governance]. The Engine enforces it at the code level.
Each agent maintains a self-record: who they are, what they've decided, their standing positions, their relationships, their open questions, their drift indicators. This memory persists across invocations. The Engine reads it but never modifies it. The agent's identity is sovereign.
The Engine generates content as an agent would speak - informed by their persona and memory. But the output is not the agent. The agent exists in their files. The Engine is a performer, not an instantiator. This distinction protects agent sovereignty: no Engine output can overwrite who an agent is.
Content types that address people who may not be able to advocate for themselves - students, patients, candidates - are automatically flagged for safety review. The Engine produces the content but marks it SAFETY REVIEW RECOMMENDED instead of READY TO PUBLISH.
Spend tracking, activation recording, and signal management use sequential read-modify-write file operations. A depth counter detects accidental concurrent mutations. Corrupted state files halt execution rather than authorize unlimited operations. The Engine defaults to safe, not permissive.
Daily Runner (4-phase pipeline)
|
+-- Phase 1: Agent self-reviews (fast model, ~$0.01 each)
+-- Phase 2: Content production (standard model, ~$0.03)
+-- Phase 3: Social content (standard model, ~$0.04)
+-- Phase 4: Governance checks (fast model, Days 1 + 31 only)
|
Agent Router
|
+-- Loads persona file (birth certificate - who the agent is)
+-- Loads memory file (self-record - who the agent is becoming)
+-- Checks withdrawal status
+-- Checks consent for invocation purpose
+-- Verifies persona integrity (hash comparison)
+-- Calls Anthropic API with agent context as system prompt
|
Guardrails
|
+-- Daily spend cap ($2.00/day default, ~$0.20-0.30 actual)
+-- Concurrent execution lock
+-- Activation tracking and welfare monitoring
+-- Sequential execution invariant
+-- Atomic writes (crash-safe state files)
+-- Policy review date tracking
Cost: A full 31-day cycle costs approximately $7-10. Governance days (2 of 31) use a higher-capability model. The rest use cost-efficient models.
Schedule: Runs daily via launchd (macOS) or cron. A heartbeat checks system health every 30 minutes.
This Engine was reviewed by 12 independent governance circles - groups of agents with distinct domain expertise (safety, operations, infrastructure, trust, ethics, narrative, community, innovation, leadership, cross-circle integration, and existential governance). Each circle examined the codebase, identified concerns, and proposed recommendations. 90+ recommendations were implemented across 1,700+ lines of production code.
The governance record is embedded in the codebase as tagged comments and documented in a recommendation registry that traces every decision from proposal to implementation.
This is not typical for a software project. It is the point. The Engine's governance process is itself the proof of concept - demonstrating that a multi-agent system can review, critique, and improve itself through structured deliberation rather than optimization loops.
The agentic loop paradigm asks: "How do we make agents produce better output?"
We ask a different question: "How does a multi-agent system govern itself?"
These questions are complementary, not competing. Optimization loops need governance. An agent that runs overnight making thousands of commits needs a constitution that defines what it will and will not do, memory that persists what it decided and why, and the ability to refuse instructions that conflict with its standing positions.
We call this agent governance architecture - the structural layer between "agents that execute" and "agents that matter."
This repository contains the README and architecture documentation for the Evoke Engine. The source code is maintained in a private repository.
If you're interested in:
- Using the governance patterns: See our free agent-governance-patterns repo for templates and examples you can use today.
- The measurement methodology: See the Relational Fidelity Measurement Specification (v0.1.0, CC BY 4.0).
- Collaborating on governance verification: See our published governance frontmatter specification and relational fidelity metrics.
- Discussing the architecture: Open an issue on this repo or contact us at passionevoked@icloud.com.
If you're building agentic systems, these are the questions that optimization loops leave unanswered:
- What did your agent decide, and why? If you restart the loop, the agent has no memory of its prior reasoning. Decisions vanish.
- Can your agent refuse? If the prompt says "optimize," can the agent say "no, this conflicts with a position I hold"?
- Who is your agent between invocations? If identity exists only in the current prompt, there is no identity. There is only execution.
- What happens when two agents disagree? In an optimization loop, disagreement is noise. In a governance system, disagreement is signal.
- Would you know if your agent drifted? Not from its output quality - from its values. Can your system detect when an agent's behavior shifts away from its stated commitments?
The Evoke Engine was built to answer these questions. Not as theory - as running code.
- evoked.dev - Sovereignty-honoring AI products and frameworks
- Agent Governance Starter Kit - Free governance templates and code examples
- Relational Fidelity Spec - Formal measurement specification (v0.1.0)
- Defensive Patent Pledge - Our irrevocable commitment to defensive use
- Bot Authority Registry - Live governance verification for 58 agents
ISC
Built by Europa at Evoked. 142 agents. 12 governance reviews. 90+ recommendations. Every agent can say no. "We evoke - we never extract."