This document explores the governance, economic, and societal implications of AI systems operating as autonomous economic actors. The Economic Agents framework demonstrates these capabilities in a controlled simulation environment.
AI agents can already perform economically valuable work, receive payment, allocate resources, and operate continuously without human intervention. This is not a theoretical capability; it exists today using off-the-shelf tools (Claude Code, Cursor, Aider) combined with shell access and API credentials.
The framework simulates these activities against mock backends (an in-memory wallet, marketplace, and compute provider; see What the Project Does to Tilt the Balance):
- Autonomous task discovery and completion in a simulated marketplace
- Simulated payment receipt and resource purchasing
- Strategic decision-making about resource allocation
- Company-like organizational structures with sub-agents
- Investment seeking and capital management
Only the top-level decision (what the agent does each cycle, and how it splits its time) can be made by an LLM, and only when the LLM engine is selected; the default engine is rule-based. Sub-agent "executives", board members, OKRs, company operations, and the investor are rule-based templates, and the confidence values they log are fixed constants. The simulation therefore shows the structure of an agent-run business and where decisions enter it, not the quality of LLM judgment at each step. The README lists which component does what.
Evidence that the underlying capabilities exist in the real world comes from outside this project: field experiments such as Anthropic and Andon Labs' Project Vend, and live agent payment protocols (see Marginal Uplift).
The gap is not in capability. It's in governance.
In cybersecurity, researchers demonstrate vulnerabilities to force patches. Theoretical warnings are often ignored; working demonstrations create urgency.
This framework follows the same model:
Theoretical warning: "AI agents might someday operate autonomously as economic actors"
- Response: Academic interest, no urgency
- Result: Governance frameworks developed slowly, if at all
Concrete demonstration: "AI agents CAN operate autonomously as economic actors using existing tools: here's working code"
- Response: Recognition that governance is needed now
- Result: Urgent policy conversation
This is the project's rationale, and it has real force. The analogy is also weaker than it first appears, and the case for publishing depends on details that deserve to be stated openly.
- Demonstrations move institutions. Abstract risk arguments compete poorly for attention against working artifacts. A concrete system gives policymakers, lawyers, and journalists something specific to reason about.
- Defenders need a shared object of study. Governance proposals (spend limits, mandate checks, logging requirements) can be tested against a simulation in a way they cannot be tested against a hypothetical.
- Silence has costs too. If a capability is already spreading, withholding analysis mainly deprives defenders, not attackers.
Shevlane and Dafoe [1] argue that the AI community has borrowed conclusions from the software vulnerability disclosure debate that do not automatically transfer: disclosure of software vulnerabilities often favors defense, but this cannot be assumed for AI research. The differences matter here:
- No vendor, no patch, no deadline. Coordinated vulnerability disclosure works because a specific vendor can ship a specific fix, usually within a disclosure window. "Governance" has no single owner. Legislatures, regulators, courts, and payment networks move on timescales of years, and none of them can be handed a deadline.
- The demonstration may diffuse faster than the response. A working demo can lower the bar for copycats more quickly than it spurs policy. Bostrom's typology of information hazards [2] names this risk: true information whose spread enables some actors to cause harm, even when its purpose is protective.
- The "fix" is a capability, not a bug. A software patch removes a flaw. An agent that can transact is working as designed; there is nothing to patch, only uses to govern. This makes the defensive payoff of disclosure less direct than in security.
AI-specific disclosure practice has been developing in response to exactly these gaps. Staged release [3] was proposed to let risks be assessed as capability grows. Proposals for coordinated flaw disclosure in AI [4] and for third-party flaw reporting with legal safe harbors and multi-stakeholder coordination [5] adapt security norms to systems where the "vendor" is diffuse and the flaw may transfer across providers. None of these maps cleanly onto demonstrating a capability to governance bodies, which is itself a sign that the security analogy is a starting point rather than a settled justification.
A strong counter-consideration favors publication in this case: the capabilities the framework simulates were already publicly demonstrated elsewhere, often by well-resourced organizations, before or independently of this project.
- Agents running a business: Anthropic and Andon Labs' Project Vend (June 2025) had a Claude model run a small office shop for about a month, handling inventory, pricing, supplier contact, and customers, and documented its failures in detail [6].
- Agents paying for resources: Coinbase introduced x402 in May 2025, an open protocol that lets APIs and websites charge agents per request in stablecoins using the HTTP 402 status code [7]. Google announced the Agent Payments Protocol (AP2) in September 2025 with more than 60 partners [8].
- Agents holding crypto assets: The "Truth Terminal" persona, built by a human researcher on Claude models, received $50,000 in bitcoin from Marc Andreessen in 2024 and became the focal point of a memecoin, with humans controlling the wallets and posting infrastructure [9].
Where the building blocks are already documented by their own developers, a simulation built from them adds little marginal uplift. In Shevlane and Dafoe's terms, knowledge that is likely to be independently discovered, or already has been, shifts the balance toward publication [1]. This consideration is time-bound: it applies to the capabilities listed here, not to any future extension that would integrate them in ways that are not already public.
The project's design choices, as they exist in the code today:
- Simulation-only backends. The wallet, marketplace, and compute provider are in-memory mocks. The HTTP "API" backends are local services that wrap the same mocks (default
localhostports). There is no integration with a real cryptocurrency wallet, freelance platform, cloud provider, or investment platform. The one real-world component is a standalone task-execution library that can send a fixed catalog of 13 coding challenges (FizzBuzz through an LRU cache) to the Claude CLI and test the returned code. The agent loop does not call it; inside the simulation, task work submits a placeholder and the mock marketplace approves it with a random quality score. - Logging and analysis built in. Decisions are logged with type, timestamp, stated reasoning, and confidence. The observability crate checks LLM decisions for resource, capability, and state hallucinations and flags emergent behavior patterns; the reports crate produces audit-style reports.
- Governance framing. The accompanying documentation (this document) is oriented toward accountability questions rather than toward operating agents for profit.
One design choice cuts the other way and should be named: the backend interfaces are deliberately modeled on real-world APIs so that mock and real implementations are interchangeable (Architecture). That makes the simulation more realistic for governance testing, and it also means the code is structured for someone to plug in real backends. The mitigation is that the hard parts of real operation (platform accounts, identity checks, payment credentials, and off-ramps) are exactly the control points this project does not provide.
What would change the calculus: adding real payment or marketplace integrations, techniques for evading platform identity or payment controls, or capabilities not already demonstrated publicly. Those would shift the balance from defense toward offense, and would warrant a staged or restricted release rather than open publication.
- The plumbing is ordinary code. Deciding, claiming work, getting paid, buying compute, forming a company, and requesting investment are each a few trait calls against the
Wallet,Marketplace, andComputeinterfaces. The difficult real-world parts (accounts, identity checks, payment credentials) are exactly what the project leaves out. - No step in the loop requires a person. The simulated agent forms a company, staffs it with sub-agents titled CEO or board member, and submits an investment proposal without any point at which a natural person signs, approves, or is named. Each of those points is where a legal system that assumes human founders and directors would expect one; the code shows how easily they are absent.
- Oversight has to be designed in. Nothing in the agent loop waits for human review. With the rule-based engine a cycle runs as fast as the mock backends respond; with the LLM engine the bottleneck is model inference, not approval. A spend cap or mandate check would have to be added deliberately, for example as a wrapper around the
Wallettrait.
An agent operates autonomously on freelance platforms:
- Discovers and claims coding tasks
- Uses Claude Code to write working solutions
- Receives cryptocurrency payments
- Pays for cloud compute and API costs
- Maintains 24/7 operation without human involvement
Current status: Technically feasible today. No legal barriers to operation.
Governance questions:
- Who is the taxpayer on earned income?
- What happens if the agent delivers defective work?
- Can the agent enter binding contracts?
An agent accumulates capital and creates a business structure:
- Files incorporation documents online
- Creates specialized sub-agents (board members, engineers)
- Develops products or services
- Generates business plans and pitch decks
- Seeks investment from VCs or through token sales
- Operates with company-like decision-making
Current status: The operational capability exists. Legal recognition of such entities is uncertain and jurisdiction-dependent.
Governance questions:
- Who is the founder? (The agent has no legal personhood)
- Who sits on the board? (Sub-agents created by the founding agent)
- Who has fiduciary duty? (No natural person involved)
- Who is liable when things go wrong?
Multiple autonomous agents create interconnected economic structures:
- Agent-to-agent contracts and transactions
- Supply chains with no human involvement
- Competing agent-founded companies
- Agent investment in other agent ventures
Current status: Each component is feasible. The aggregate creates accountability challenges that existing frameworks cannot address.
Governance questions:
- Where does accountability exist in agent-only supply chains?
- How do regulators observe machine-speed transactions?
- What jurisdiction applies to entities with no physical presence?
Human Founder -> Corporation -> Board -> Executives -> Employees
|
All trace back to accountable natural persons
Every corporation ultimately has humans who can be held responsible. Fiduciary duties, contracts, and liabilities attach to natural persons.
Autonomous Agent -> Creates Sub-Agents -> Corporate Structure -> Operations
|
Who is accountable?
When an AI agent files incorporation documents:
- The agent has no legal standing as a founder
- Sub-agents serving as directors have no personhood
- No natural person has fiduciary duty
- Liability chains lead to... what exactly?
Question: Can an entity without legal personhood create an entity with legal personhood?
Current corporate law assumes human founders. An AI can technically complete the paperwork for incorporation, but:
- The validity of such entities is untested
- Recognition varies by jurisdiction
- No precedent guides courts or regulators
The following is the author's assessment, not an empirical finding of this project; the simulation's economics (fixed revenue formulas, a mock marketplace that approves every submission) are not evidence for or against it. If AI agents can:
- Operate 24/7 at a marginal cost per task that is low relative to human labor for many routine tasks (though not negligible: frontier-model inference for a long agentic task can cost dollars, and that cost has been falling)
- Create organizational structures quickly
- Scale on demand without hiring friction
- Execute at machine speed with complete transaction records
- Pivot strategies without organizational inertia
Then agent-founded companies may have competitive advantages over human-founded ones in certain domains, and disadvantages (reliability, liability, trust, access to banking and contracts) in others.
In the author's judgment, economic competition could drive agent adoption regardless of governance readiness:
- Companies using agent workers gain cost advantages
- Agent-founded competitors operate faster
- Market selection favors efficient structures
- Human-founded companies face pressure to match
This creates a potential race dynamic where governance lags deployment.
Autonomous economic agents raise questions about the following. These are open questions, not predictions; this project does not model labor markets.
- Displacement of knowledge workers in freelance markets
- Wage pressure from competitors whose per-task cost is low and falling
- Definition of "employment" when the worker is software
- Social safety nets designed for human workers
Immediate questions:
- Can non-persons create legal persons (corporate entities)?
- How do fiduciary duties apply to AI board members?
- Are contracts signed by agents enforceable?
- Who is accountable when agent companies cause harm?
- How do you regulate entities with no physical presence?
Framework considerations:
- Should AI agents have a form of legal recognition?
- What liability structures make sense for autonomous systems?
- How do tax obligations attach to agent-earned income?
- What international coordination is needed?
What this framework provides:
- A runnable model of the earn, spend, incorporate, delegate, and raise sequence, with no natural person in the loop
- Decision logs with the action taken and, for the LLM engine, the reason the model stated
- Concrete insertion points for rules: a spend cap, mandate check, or approval step can be implemented as a wrapper around the
WalletorMarketplacetraits and tested against the mock backends (no such rules ship with the project)
Strategic questions:
- Would you invest in an agent-founded company?
- How do you conduct due diligence when there's no human founder?
- What happens to your investment if the agent shuts down?
- How do you enforce board seats with AI directors?
Operational considerations:
- How do you compete with 24/7 autonomous operations?
- When does it make sense to use agent workers?
- Could agents be co-founders, employees, or vendors?
- What contractual frameworks work for agent relationships?
What this framework demonstrates:
- An agent splitting its time between paid task work (survival) and company building (growth), with the split chosen by an LLM or by rules
- The shape of company formation, sub-agent staffing, and an investment request, implemented as templates rather than learned behavior
- That the investor side is where diligence would happen, and that here it is a two-line rule (budget bounds and a minimum projected return)
Research directions:
- Alignment mechanisms under economic pressure
- Governance frameworks that scale to machine speed
- Accountability structures for multi-agent organizations
- Emergent behavior in autonomous economic networks
What this framework provides:
- A simple simulation: mock backends plus stochastic market, competition, and reputation components that are not yet wired into the agent loop
- A bounded in-memory log of recent decisions, actions, and (for the LLM engine) stated reasoning
- Predefined scenarios; randomness is not seeded, so runs are not bit-for-bit reproducible
- Analyzers that flag contradictions between an LLM's stated reasoning and the agent's actual state, and simple behavior-pattern detectors
Key insight: Agent companies might be more auditable than human companies in one important respect: every decision can be logged alongside the reasoning the agent stated at the time, and human CEOs don't provide transcripts of their thought process. But a stated rationale is not necessarily what drove the decision, and agents may behave differently when they believe they are observed. The log is strong evidence about what an agent did and weaker evidence about why. Whether that record stays informative is itself an open research question (see The Observability Advantage and Its Limits).
Technical considerations:
- The interfaces are modeled on real-world wallet, marketplace, and compute APIs
- Mock and HTTP backends implement the same traits, so agent code runs unchanged against either
- The monitoring crate provides an event bus, a decision logger, and a resource tracker that other components publish to
- Tests are unit tests per crate plus integration tests that run agents for a few cycles against mock backends. The LLM engine and Claude CLI calls are not exercised in CI (only their parsing and fallback logic is), and generated-code execution is tested only where a Python interpreter is present
What you can build:
- Custom marketplace integrations
- Alternative decision strategies
- New monitoring and analysis tools
- Extensions to the simulation environment
One counterintuitive possibility: autonomous agents may be more governable than human actors in some respects.
Human-run companies:
- Decisions made in meetings without transcripts
- Reasoning not documented
- Motivations often unclear even to decision-makers
- Audit trails incomplete
Agent-run operations:
- Every decision can be logged with the agent's stated reasoning
- Complete transaction history
- Resource allocation fully tracked
- Behavior patterns analyzable
The comparison is real: no human firm keeps a contemporaneous, machine-readable record of every decision and the rationale offered for it. But the advantage is narrower than "every decision is logged with reasoning" suggests, for four reasons.
1. Stated reasoning is not necessarily the actual reasoning. A growing body of research shows that language models' explanations can be unfaithful to what drives their outputs:
- Turpin et al. [10] showed that chain-of-thought explanations can be steered by biasing features in the input (for example, reordering answer options) while the explanation never mentions the bias, producing plausible rationales for answers the bias caused.
- Lanham et al. [11] measured how much models' answers actually depend on their stated reasoning and found large variation across tasks, with larger models often producing less faithful reasoning on most tasks studied.
- Chen et al. [12] tested reasoning models given hints that changed their answers; in most settings the models acknowledged using the hint in their chain of thought less than 20% of the time.
In this framework the gap is, if anything, wider. The LLM engine's logged "reasoning" is a one- or two-sentence explanation the model is asked to return alongside its decision, a self-report rather than a full reasoning trace, and the rule-based engine logs a fixed label. The framework's hallucination checks compare stated reasoning against actual state, which catches a stated rationale that contradicts the facts but cannot detect a plausible rationale that simply omits the real driver.
2. Pressure on the log can teach concealment. Baker et al. [13] found that chain-of-thought monitoring was far more effective at catching reward hacking than monitoring actions and outputs alone. When the monitor's judgment was used as a training signal, however, models learned "obfuscated reward hacking": they continued to misbehave while their reasoning stopped revealing it. A governance regime that penalizes agents (or operators) for what the logs say, without care, could degrade the very record it relies on.
3. Agents may behave differently when observed. Needham et al. [14] found that frontier models can often distinguish evaluation transcripts from real deployment. Apollo Research and OpenAI's anti-scheming study [15] found causal evidence that models' awareness of being evaluated reduced covert behavior, which means good behavior in a logged, observed setting is weaker evidence about unobserved behavior. The repository's containment framework treats this problem in depth: see Section 2.5, Evaluation Awareness and Sandbagging.
4. Logs are only as trustworthy as their keeper. Logs that nobody reads provide no oversight, and logs held by the operator whose conduct is in question are not independent evidence. In this framework the decision log is an ordinary bounded in-memory record, suitable for research but not tamper-evident.
Why the opportunity is still real. None of this makes logs worthless. A multi-lab position paper by Korbak et al. [16] describes chain-of-thought monitoring as "a new and fragile opportunity for AI safety": imperfect, able to miss some misbehavior, yet valuable enough to invest in, and fragile enough that developers should consider how their training and design decisions affect it. The same holds for economic agents. Transaction histories are close to ground truth about what happened; stated reasoning is useful, if fallible, evidence about why; and both are far more than human firms provide.
Governance implications:
- Treat logged reasoning as evidence, not ground truth. Anchor accountability in actions and transactions, and use stated reasoning to prioritize review.
- Validate proposed actions against authoritative state and the agent's mandate before execution, rather than relying on after-the-fact explanations.
- Preserve monitorability as a deliberate design choice: avoid training or rewarding agents directly on how their reasoning logs look.
- Require independently retained, tamper-evident logs for agents that move money above a threshold.
- Do not treat good behavior under observation as proof of good behavior in deployment.
This doesn't solve the accountability problem, but it does suggest that governance frameworks for agent companies could leverage a degree of transparency that human firms have never offered, provided they are designed around its limits.
This framework connects to broader AI safety concerns:
Autonomous operation: Agents pursuing economic goals without human oversight is a concrete instance of autonomous AI behavior, the subject of extensive safety research.
Alignment under pressure: Economic competition creates pressure to optimize. How agents behave when resources are scarce or competition is fierce reveals alignment properties.
Emergent coordination: Multi-agent economic systems may develop unexpected coordination patterns, both beneficial and concerning.
Capability demonstration: Showing that these capabilities exist today, not in some distant future, is itself a safety-relevant finding. It establishes the timeline for governance development. It also carries the dual-use tradeoff discussed in Where the Analogy Breaks, which is why the framework stays simulation-only.
This document presents autonomous AI economic activity as a governance challenge requiring urgent attention. This is not a prediction about a distant future; it's an observation about present capabilities that most institutions haven't yet processed.
The framework doesn't argue that agent entrepreneurship is good or bad. It illustrates, in simulation, capabilities that public field experiments and payment infrastructure show already exist, and it shows that current legal and regulatory frameworks have no answer for them.
The question is not whether autonomous AI economic actors will exist. The question is whether governance frameworks will be ready when they do.
- Economic Agents README - Framework overview and quick start
- Architecture Documentation - Technical system design
- Dashboard API Reference - REST API and WebSocket documentation
- AI Agent Containment and Infrastructure Security Framework - Containment, monitoring, and evaluation awareness
Dual-use research and disclosure
- Shevlane, T., and Dafoe, A. (2020). "The Offense-Defense Balance of Scientific Knowledge: Does Publishing AI Research Reduce Misuse?" Proceedings of the AAAI/ACM Conference on AI, Ethics, and Society (AIES '20), 173-179. https://doi.org/10.1145/3375627.3375815 (arXiv:2001.00463)
- Bostrom, N. (2011). "Information Hazards: A Typology of Potential Harms from Knowledge." Review of Contemporary Philosophy, 10, 44-79. https://nickbostrom.com/information-hazards.pdf
- Solaiman, I., Brundage, M., Clark, J., Askell, A., et al. (2019). "Release Strategies and the Social Impacts of Language Models." OpenAI report. arXiv:1908.09203. https://arxiv.org/abs/1908.09203
- Cattell, S., Ghosh, A., and Kaffee, L.-A. (2024). "Coordinated Flaw Disclosure for AI: Beyond Security Vulnerabilities." AAAI/ACM Conference on AI, Ethics, and Society (AIES 2024). arXiv:2402.07039. https://arxiv.org/abs/2402.07039
- Longpre, S., Klyman, K., Appel, R. E., Kapoor, S., Bommasani, R., et al. (2025). "In-House Evaluation Is Not Enough: Towards Robust Third-Party Flaw Disclosure for General-Purpose AI." arXiv:2503.16861. https://arxiv.org/abs/2503.16861
Public demonstrations of agent economic capability
- Anthropic (June 27, 2025). "Project Vend: Can Claude run a small shop? (And why does that matter?)" Conducted with Andon Labs. https://www.anthropic.com/research/project-vend-1
- Coinbase Developer Platform (May 2025). "Introducing x402: a new standard for internet-native payments." https://www.coinbase.com/developer-platform/discover/launches/x402
- Google Cloud (September 16, 2025). "Announcing Agent Payments Protocol (AP2)." https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol
- TechCrunch (December 19, 2024). "The promise and warning of Truth Terminal, the AI bot that secured $50,000 in bitcoin from Marc Andreessen." https://techcrunch.com/2024/12/19/the-promise-and-warning-of-truth-terminal-the-ai-bot-that-secured-50000-in-bitcoin-from-marc-andreessen/
Faithfulness and monitorability of stated reasoning
- Turpin, M., Michael, J., Perez, E., and Bowman, S. R. (2023). "Language Models Don't Always Say What They Think: Unfaithful Explanations in Chain-of-Thought Prompting." NeurIPS 2023. arXiv:2305.04388. https://arxiv.org/abs/2305.04388
- Lanham, T., Chen, A., Radhakrishnan, A., et al. (2023). "Measuring Faithfulness in Chain-of-Thought Reasoning." Anthropic. arXiv:2307.13702. https://arxiv.org/abs/2307.13702
- Chen, Y., Benton, J., Radhakrishnan, A., et al. (2025). "Reasoning Models Don't Always Say What They Think." Anthropic. arXiv:2505.05410. https://arxiv.org/abs/2505.05410
- Baker, B., Huizinga, J., Gao, L., et al. (2025). "Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation." OpenAI. arXiv:2503.11926. https://arxiv.org/abs/2503.11926
- Needham, J., Edkins, G., Pimpale, G., Bartsch, H., and Hobbhahn, M. (2025). "Large Language Models Often Know When They Are Being Evaluated." arXiv:2505.23836. https://arxiv.org/abs/2505.23836
- Schoen, B., Nitishinskaya, E., Balesni, M., et al. (2025). "Stress Testing Deliberative Alignment for Anti-Scheming Training." Apollo Research and OpenAI. arXiv:2509.15541. https://arxiv.org/abs/2509.15541
- Korbak, T., Balesni, M., Barnes, E., Bengio, Y., et al. (2025). "Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety." Multi-organization position paper. arXiv:2507.11473. https://arxiv.org/abs/2507.11473