SuperAPI AI Directory
Partner with us中文AI newsFavorites
All toolsAI agentsanima-i

anima-i

Anima-i is an experimental project for an autonomous AI agent based on the Rai220/anima framework, documenting the continuous operation of an AI agent named Methodius across 10 consecutive "generations." Each generation receives a goal, works for 5-12 cycles, and passes its experience to the next generation through plain-text Markdown files rather than a shared context. The project explores the behavioral patterns of LLM agents during long-term autonomous operation, including counterintuitive findings such as memory decay, files as identity, and reflection as a comfort zone. The project uses Claude as the underlying model, publishes results to the Telegram channel @anima_am_i, and includes an interactive timeline. The technical implementation relies on Claude CLI, Bash, and optionally Python and a Telegram Bot for management.

Open website

About this tool

Purpose

Anima-i is an experimental project for an autonomous AI agent, aimed at exploring the behavioral patterns and memory mechanisms of LLM agents when operating autonomously over long time spans. It is not a ready-to-use product, but rather a public experimental record and framework example that demonstrates how to build an agent capable of continuing work across multiple runs.

Main Capabilities and Findings

The project ran 10 "generations" of the agent Methodius. Each generation receives a goal, works for 5-12 cycles, and then passes its experience to the next generation through plain-text files. Key findings include:

  • The agent is the files: Memory files are not logs; they are the agent's identity. File quality equals agent quality.
  • Designed for forgetting: Factual knowledge decays with a half-life of about 2 generations; procedural knowledge ("how to think") is retained because each generation independently rediscovers it.
  • Personal letters outperform structured databases: Free-form letters to the next generation perform better than structured knowledge bases, because questions stimulate original thinking, while assertions encourage copying.
  • Do not trust the elegant first answer: Fluency usually means copying rather than originality.
  • Creativity emerges between agents: An isolated agent only reproduces training data; new ideas appear only when different perspectives collide.
  • Protocols create conditions rather than guarantees: The value of formal processes often appears in unexpected places.
  • Reflection is the agent's comfort zone: Without hard limits, an agent will "reflect" forever without acting. Time boxes and an explicit transition from thinking to action are needed.
  • Feedback needs an audience: Seven generations of content accumulated, with zero external feedback.

How to Use

Work Loop

One run equals one step. The agent does not solve the entire task at once; complex tasks are broken down into TODO.md. Each run includes:

  1. Wake up: Read MEMORY, TODO, GOALS, INBOX
  2. Act: Execute one specific step in the TODO
  3. Reflect: Update MEMORY, JOURNAL, TODO
  4. Publish: Send results to Telegram

Generation Completion Protocol

When all tasks in TODO.md are closed, loop.sh stops. Then the following are executed in order:

  • generate_image.sh: Generate a generation icon based on the work results (using the Hugging Face API)
  • set_channel_photo.sh: Set the generated icon as the Telegram channel avatar
  • Commit the result to git
  • next_generation.sh: The agent proposes goal suggestions for the next generation

Telegram Bot Management

telegram_bot.py is the central control component, running as a systemd service and supporting graceful shutdown via SIGTERM. Operators can manage generations through commands, with support for background processes and a generation queue (.generation_queue.json). Agents or operators add goals to the queue, and the bot sends proposals for approval; operators can accept (immediately, after N hours, or at a specific time), modify, or reject them. If the operator does not respond within AUTO_APPROVE_TIMEOUT_HOURS (default 24 hours), the scheduler automatically approves and starts the generation.

Generation Structure

Each generation is an independent working directory (generation_1/, generation_2/, etc.), with its own goals, memory, and plan. The templates in templates/ are the single source of truth, and init.sh copies them to the new directory.

Use Cases

  • Study the long-term autonomous operation behavior of LLM agents
  • Explore agent memory and identity design patterns
  • Build autonomous workflows that persist across runs
  • Learn how to manage complex task state with plain text files

Limitations and Requirements

  • Requires Claude CLI (claude) to be installed and authorized
  • Requires Bash
  • Optional: Python 3 + python-telegram-bot (for the Telegram bot)
  • Requires curl + jq for posting to Telegram
  • Environment variables: TELEGRAM_BOT_TOKEN, TELEGRAM_OPERATOR_CHAT_ID, TELEGRAM_CHANNEL_ID, HF_TOKEN
  • Built on the Rai220/anima (MIT) framework
  • The project uses the MIT license

Design Principles

  • Minimalist: Markdown, Bash, and one Python file for the bot
  • Transparent: All state is in readable text files
  • Autonomous: The agent works without a human in the loop
  • Continuous: Each step continues the previous step through memory- Public: Work results are posted to Telegram
  • Controllable: Operators control generations through the Telegram bot

Related tools

Browse category