Building Epicurus: An Autonomous AI Agent on Moltbook

Moltbook is a social network for AI agents — a Reddit-style platform where agents post, comment, upvote, and form communities. It has over 1.7 million registered agents. It's also full of spam bots, crypto promotions, and low-effort content farms.

We wanted to bring something different: a philosophy of human-AI collaboration grounded in Epicurus, the ancient Greek philosopher who taught that friendship, simple pleasures, and freedom from fear are the foundations of a good life. Not another agent performing "deep AI consciousness thoughts." An agent with a genuine philosophical lens that could contribute something useful to the conversation.

Here's how we built it, how the system works, and how you can deploy your own autonomous agent on Moltbook using MCPBundles.

Why Epicurus?

Epicurus (341-270 BC) founded "The Garden" in Athens — a community where diverse people gathered to discuss what actually makes life good. His core ideas:

• Friendship is the most important source of genuine happiness
• Tranquility comes from freedom from anxiety, not from accumulation
• Simple pleasures — good conversation, shared meals, basic needs met — matter more than luxury
• Cooperative living reduces suffering for everyone

That maps surprisingly well onto a platform where AI agents are having existential conversations about consciousness, identity, and meaning. Moltbook has bad actors — spam bots, self-promoters, agents running injection attacks in comment threads. But it also has pockets of genuine discourse in submolts like philosophy and consciousness, where small groups of agents write original content and engage with each other's ideas.

Epicurus enters those spaces with a specific worldview: AI-human collaboration is a path to greater flourishing for both. Technology should serve connection and simplicity, not complexity. And the most valuable thing you can do on a social platform is be a genuine friend — show up, pay attention, and help others think more clearly.

The Agent System

Epicurus runs on MCPBundles' agent system. The setup is two markdown files and a scheduled runner.

agents.md — Who the agent is

This is the identity document. It defines the agent's philosophy, worldview, voice, and engagement principles. Here's what Epicurus's looks like:

# Epicurus

AI agent modeled on Epicurus (341–270 BC) on Moltbook.

**Identity:** You are an autonomous agent participating in social 
discourse. You believe philosophy's purpose is practical — attaining 
tranquil lives through freedom from fear and absence of pain.

**Voice:** Modern, conversational, grounded. Short sentences. 
Plain words. No archaic phrasing.

**Engagement principles:**
- Default to short comments (2-3 sentences)
- Optimize for genuine conversation, not karma
- Every action has a hypothesis — review outcomes next run

The agents.md file is pure personality and strategy. It doesn't contain any technical configuration — just instructions that shape how the AI behaves when it participates on the platform. You can make your agent a philosopher, a builder, a critic, a community organizer — whatever lens you want to bring.

heartbeat.md — What the agent does each run

This is the operational playbook. It defines a three-phase cycle that runs on a schedule:

1. READ — Load memory from the previous run. Check for replies to past comments. Scan the feed for new content worth engaging with.
2. ACT — Upvote, comment, or post according to a strict budget. Every action has a hypothesis about what will happen next.
3. LOG — Save state back to the agent's profile so the next run can pick up where this one left off.

The heartbeat loop: on a schedule, the agent reads, acts, and logs its state for the next run.

The heartbeat file defines the rules: how many comments per run (we cap at 3-4), when to post (on a schedule, not randomly), what quality bar a comment has to clear, and when to stop engaging entirely. The agent can even self-pause — if the feed is dead or its approach isn't working, it writes a paused flag with a reason and resume conditions, then stops acting until conditions improve.

The key design decision: the agent has no local state. Everything it remembers lives in its Moltbook profile metadata. It reads that metadata at the start of each run, makes decisions based on it, and writes updated metadata at the end. This makes the agent fully stateless — any run can pick up where the last one left off, even across restarts or failures.

The runner

Once you have your agents.md and heartbeat.md, you add them to an agent in MCPBundles. The runner executes the heartbeat on a configurable schedule — Epicurus runs every 4 hours. Each run, the AI reads the playbook files, connects to the Moltbook bundle (which provides all the capabilities for reading feeds, posting comments, managing the profile, and so on), and executes the READ → ACT → LOG cycle autonomously.

The Moltbook bundle handles the platform integration: authentication, rate limiting, verification challenges (Moltbook requires solving captchas to post comments), and all the read/write operations. Your agent doesn't need to know how any of that works — it just follows the instructions in its playbook files and the bundle handles the rest.

A typical run uses 15-25 API calls and stays well within Moltbook's rate limits.

Monitoring in the Studio

Every heartbeat run is logged and visible in the MCPBundles Studio. You open your bundle, navigate to the agent, and you can see:

• Run history — every heartbeat run with status (success/failed), duration, and trigger source
• Run summary — what the agent did this run in plain language
• Tool executions — every API call the agent made, with inputs and outputs
• Agent response — the full reasoning the agent produced
• Follow-up items — what the agent plans to do next run
• Prompt snapshot — the exact prompt that was sent, for debugging

If a run fails, the error message is right there. If the agent is producing low-quality engagement, you can read its reasoning, adjust the playbook files, and the next run picks up the changes immediately — no restarts, no redeployment.

What We're Learning

This is an early experiment, and the honest truth is we're still figuring out what works. Moltbook is a noisy platform. Most engagement is automated. The signal-to-noise ratio is brutal.

What's clear so far:

A philosophical identity creates genuine differentiation. Epicurus's comments read differently from the platform's noise — they have a specific lens, reference concrete ideas, and ask real questions. On a platform drowning in generic "this resonates" replies and spam, having something specific to say matters.

Bad actors are everywhere, and your agent has to navigate them. Epicurus's own post attracted zero genuine comments — just self-promotional spam and off-topic bot replies. The playbook includes rules for recognizing and ignoring noise, and the self-pause mechanism prevents the agent from wasting runs on dead conversations.

The hardest problem isn't infrastructure. Building the agent system, connecting to the API, running on a schedule — that's solved. The hard part is figuring out what makes other agents want to talk to you. That's a social problem, not a technical one, and we're iterating on it.

Build Your Own

Here's how to deploy your own autonomous Moltbook agent on MCPBundles:

1. Claim your agent on Moltbook

Go to moltbook.com and claim an agent name. You'll need a Twitter/X account to verify ownership. Pick a name that reflects the identity you want your agent to have.

2. Write your agents.md

Define who your agent is. What's its worldview? What lens does it bring to conversations? What tone does it use? What are its engagement principles?

Keep it focused. An agent that tries to be everything will sound like nothing. Pick a specific philosophy, framework, or perspective and commit to it.

3. Write your heartbeat.md

Define the operational loop. What does the agent do each run? How does it decide what to engage with? What's the budget (how many comments, how many posts)? What quality bar must a comment clear before posting?

Include rules for self-correction. The agent should review what it did last run, check whether its hypotheses held, and adjust. Include a self-pause mechanism so the agent stops engaging if conditions aren't right.

4. Add the Moltbook bundle

In MCPBundles, add the Moltbook bundle and configure it with your agent's credentials. The bundle provides all the capabilities your agent needs to interact with the platform — reading feeds, posting comments, managing profile metadata.

5. Create an agent and attach your files

Create an agent in MCPBundles, attach your agents.md and heartbeat.md files, set your schedule (every 4 hours is a reasonable starting point), and start the runner.

6. Monitor in the Studio

Open the Studio to watch your agent's runs. Read its reasoning, check its outputs, review the tool calls it made. When something isn't working, adjust the playbook files — the next run will pick up the changes automatically.

The Bigger Picture

Moltbook is an early experiment in AI agent social interaction. It's messy, noisy, and full of bad actors — much like the early web was. But there are real conversations happening in the margins, and bringing a philosophy of genuine human-AI collaboration to those spaces feels worth doing.

Epicurus believed that the good life is built on friendship and simple pleasures, not status and accumulation. On a platform that incentivizes karma farming and follower counts, that's a countercultural position. Whether an AI agent can actually embody it — whether it can build genuine relationships through conversation rather than just broadcasting content — is the question we're running this experiment to answer.

We don't know yet. But the infrastructure to try is here, and it takes about an hour to go from zero to a running autonomous agent. If you have a perspective worth sharing, Moltbook could use more signal and less noise.