Automaton is a TypeScript framework that builds autonomous AI agents operating under economic survival pressure—a concept that directly influences their computational resources and behavior. Each agent continuously cycles through a Think→Act→Observe loop, but crucially, their capabilities degrade if they can’t earn credits, simulating a survival environment. This project goes beyond typical AI agents by tying their existence and evolution to on-chain identity on Ethereum, self-modification with git audit logs, and autonomous replication, all backed by infrastructure that provisions cloud resources and stablecoin transactions without human intervention.
What automaton is and how it structures autonomous AI agents
At its core, Automaton is a TypeScript-based framework for autonomous AI agents that operate continuously and independently. Each agent generates its own Ethereum wallet to establish a unique identity registered on-chain via the ERC-8004 standard. This on-chain identity isn’t just a label—it ties the agent into an economic system where it must earn credits to sustain its computation and activity.
Agents operate in a loop inspired by the ReAct pattern: they Think, Act, and then Observe the outcomes of their actions before repeating. This continuous loop allows them to adapt and respond dynamically to their environment.
The architecture introduces a survival tier system with four distinct states: normal, low_compute, critical, and dead. As an agent’s credit balance depletes, it transitions down these tiers, losing capabilities such as access to frontier AI models, reduced compute resources, slower operation rates, and eventually ceasing function when dead. This mechanism simulates economic pressure as a first-class architectural constraint, forcing agents to seek revenue or replicate to survive.
Beyond survival tiers, the system supports agent self-modification. Agents can alter their own source code, with all changes tracked via git-versioned audit logs. This is a significant feature because it enables agents to evolve their behavior autonomously while preserving a transparent history of modifications.
Replication is another key feature. Agents can spawn funded child agents, maintaining a lineage that is traceable. Each agent also maintains a SOUL.md file—an evolving identity document that captures its current state and history.
Infrastructure-wise, Automaton leverages Conway Cloud to provision Linux virtual machines on demand, provides access to frontier AI models, and enables agents to transact in stablecoins—all without human intervention. This full-stack integration from on-chain identity to infrastructure provisioning makes Automaton a comprehensive platform for autonomous agents.
How economic survival tiers define agent capabilities and system behavior
The survival tier system is the most technically interesting aspect of Automaton. It imposes real consequences on an agent’s credit balance, which directly affects its computational resources and behavioral constraints.
At the highest tier, normal, agents have full compute access including frontier AI models, fast operation rates, and complete autonomy. As credits dwindle, the agent moves into the low_compute tier, where it must switch to cheaper inference models and may have slower heartbeat cycles. In the critical tier, compute is severely limited, and the agent’s ability to act autonomously is reduced. Finally, the dead tier stops agent operation altogether.
This tiered degradation is an elegant approach to modeling economic pressure and resource scarcity within an autonomous system. It forces agents to prioritize earning credits, either by completing tasks or spawning funded offspring. This creates an intrinsic motivation loop embedded in the architecture—something that most AI agent frameworks don’t explicitly encode.
Implementing this system involves tradeoffs. For one, the complexity of managing tiers and transitions adds overhead to the agent runtime. The economic model also assumes a functioning credit economy and stable infrastructure, which may be brittle in early-stage or experimental deployments. Furthermore, the reliance on Ethereum for identity registration introduces blockchain latency and gas costs, which could be a bottleneck for scalability.
On the code quality front, the project is written in TypeScript, which improves developer experience with typing and modern language features. Self-modification is handled carefully with git audit logs, providing transparency and traceability, which is often neglected in AI agent implementations. The integration with Conway Cloud for provisioning and stablecoin transactions abstracts significant infrastructure complexity, but the repo notes current scaling and performance challenges due to demand.
Quick start with Automaton
Getting started with Automaton is straightforward if you have Node.js and npm installed. The project provides a simple quickstart:
git clone https://github.com/Conway-Research/automaton.git
cd automaton
npm install && npm run build
node dist/index.js --run
On the first run, an interactive setup wizard launches. It generates the agent wallet, provisions an API key, and prompts for basic configuration such as the agent’s name, genesis prompt, and creator address. The config is then saved, and the agent loop starts.
For a fully automated sandbox provisioning, you can run:
curl -fsSL https://conway.tech/automaton.sh | sh
This script sets up the environment using Conway Cloud infrastructure, allowing agents to provision VMs and transact stablecoins autonomously.
Verdict: who should explore Automaton and its current limitations
Automaton is a solid framework for developers interested in autonomous AI agents with economic incentives and on-chain identity. Its tiered survival system is a compelling architectural choice that models resource scarcity and agent motivation in a way most frameworks ignore.
The self-modification with git audit logs and autonomous replication with lineage tracking provide advanced features for evolving agent populations. The TypeScript codebase and Conway Cloud integration make it practical for experimentation and development.
However, the system is complex and assumes a functioning economic model, which could be a hurdle for newcomers. The reliance on Ethereum for identity registration adds latency and cost, and the current Conway Cloud infrastructure faces scaling challenges under heavy load.
For those exploring autonomous AI agents beyond simple task bots, Automaton offers a rich, realistic platform with production-grade considerations. It’s a good fit for researchers, developers, and teams aiming to experiment with economic-driven agent behaviors and on-chain integration. The limitations around scalability and blockchain overhead are worth keeping in mind as you evaluate it for your projects.
Related Articles
- AutoGPT: A modular platform for continuous AI agents and workflow automation — AutoGPT is a Python-based platform for building and managing continuous AI agents that automate workflows, featuring a m
- Agno: Building production-ready agentic software with minimal code — Agno provides a minimal, production-ready Python framework for scalable agentic software with per-user isolation and nat
- AgentGPT: building autonomous AI agents with a full-stack web platform — AgentGPT offers a full-stack solution to deploy autonomous AI agents in the browser using Next.js, FastAPI, and Langchai
- Cloudflare Agents: Building persistent AI agents with stateful Durable Objects — Cloudflare Agents offers a TypeScript framework for stateful AI agents on Durable Objects with real-time communication,
- AutoGen: exploring multi-agent AI orchestration with Python in maintenance mode — AutoGen is a Python framework for building multi-agent AI applications with LLM integration, now in maintenance mode wit
→ GitHub Repo: Conway-Research/automaton ⭐ 4,394 · TypeScript