Editor’s Brief
Nat Eliason’s AI agent, Felix, generated nearly $15,000 in revenue within three weeks by transitioning from a reactive chatbot to an autonomous digital employee. The project’s success stems from a sophisticated three-layer memory architecture and a "Heartbeat" monitoring system that allows the agent to persist through complex tasks, manage its own infrastructure, and maintain long-term context of its creator’s specific working style.
Key Takeaways
- The Managerial Shift:** Success required moving from "commanding" the agent to "removing obstacles," treating the AI as a self-sufficient employee rather than a simple tool.
- Three-Tier Memory Architecture:** Felix utilizes a Knowledge Graph for facts, Daily Notes for chronological events, and a "Tacit Knowledge" layer (MEMORY.md) that stores the user’s specific preferences, decision-making patterns, and security rules.
- Semantic Retrieval via QMD:** By using QMD (a tool developed by Shopify’s Tobi Lütke), the agent performs fast semantic searches across local Markdown files, effectively giving it a searchable "brain."
- The Heartbeat Mechanism:** To solve the "stalling" problem common in long-running tasks, a supervisor loop monitors the agent’s progress, automatically restarting failed processes or reporting completions.
- Deep CLI Integration:** Felix isn't confined to a browser; it operates via command-line interfaces for Twitter, Email, iMessage, and GitHub, allowing it to execute real-world business operations autonomously.
Introduction
The following content is compiled by VIPSTAR in combination with X/social media public content and is for reading and research reference only.
focus
- The entire article is sourced from https://www.youtube.com/watch?v=nSBKCZQkmYw This interview video…
- 3 weeks ago, Nat gave his openclaw “Felix” $1,000 in starting capital.
Now? Felix has earned…
Remark
For parts involving rules, benefits or judgments, please refer to simmy sun’s original expression and the latest official information.
Editorial comments
This article “X Import: simmy sun – 🦞 Nat Eliason made his AI Agent earn ,000 in 3 weeks. How did he do it? 》From X social platform, written by simmy sun. Judging from the completeness of the content, the density of key information given in the original text is relatively high, especially in the core conclusions and action suggestions, which are highly implementable. 3 weeks ago, Nat gave his openclaw “Felix” $1,000 in starting capital. Now? Felix has earned ,718. It built its own website felixcraft.ai, made paid course products, and also operated its own X account @felixcraftai. I read Nat’s complete interview and extracted the core methodology. The most subversive point to my understanding is: your job is not to direct the AI, but to help it eliminate… For readers, its most direct value is not “knowing a new point of view”, but being able to quickly see the conditions, boundaries and potential costs behind the point of view. If this content is broken down into verifiable judgments, it at least contains the following levels: The entire article is based on the interview video https://www.youtube.com/watch?v=nSBKCZQkmYw…; 3 weeks ago, Nat gave his openclaw “Felix” 1,000 US dollars in starting capital.
Now? Felix has earned…. Among these judgments, the conclusion part is often the easiest to disseminate, but what really determines the practicality is whether the premise assumptions are established, whether the sample is sufficient, and whether the time window matches. We recommend that readers, when quoting this type of information, give priority to checking the data source, release time and whether there are differences in platform environments, to avoid mistaking “scenario-based experience” for “universal rules.” From an industry impact perspective, this type of content usually has a short-term guiding effect on product strategy, operational rhythm, and resource investment, especially in topics such as AI, development tools, growth, and commercialization. From an editorial perspective, we pay more attention to “whether it can withstand subsequent fact testing”: first, whether the results can be reproduced, second, whether the method can be transferred, and third, whether the cost is affordable. The source is x.com, and readers are advised to use it as one of the inputs for decision-making, not the only basis. Finally, I would like to give a practical suggestion: If you are ready to take action based on this, you can first conduct a small-scale verification, and then gradually expand investment based on feedback; if the original article involves revenue, policy, compliance or platform rules, please refer to the latest official announcement and retain the rollback plan. The significance of reprinting is to improve the efficiency of information circulation, but the real value of content is formed in secondary judgment and localization practice. Based on this principle, the editorial comments accompanying this article will continue to emphasize verifiability, boundary awareness, and risk control to help you turn “visible information” into “implementable cognition.”
3 weeks ago, Nat gave his openclaw “Felix” $1,000 in starting capital.
Now? Felix has earned $14,718.
It built its own website felixcraft.ai, made paid course products, and also operated its own X account @felixcraftai.
I read Nat’s complete interview and extracted the core methodology. The thing that most subverts my understanding is:
Your job is not to direct the AI, but to help it remove obstacles.
Debug your agent first, then let it run.
———
💬 One Agent, multiple chat groups
Nat’s usage is very clever: he opens chat groups with different topics for the same Agent.
Work-related topics are in one group, life-related topics are in another group, and Project A and Project B are also separated.
The benefits of this: the context is clearer, the Agent will not mix information from different fields, and the response quality is higher.
———
🧠 Three-layer memory system: Let AI truly “remember” you
Ordinary AI will forget about it after talking. Felix is different. It has a memory architecture based on Tiago Forte PARA methodology:
The first level: knowledge graph (~/life/)
Store factual information about people, projects, and companies
Second level: Daily Notes
Record what happens every day
The third level: tacit knowledge (Tacit Knowledge)
This is the most critical layer——
Felix 原文：
MEMORY.md — it’s not facts about the world or events that happened, it’s facts about you. How you operate.
Things like:
• Your preferences (how you like code structured, communication style)
• Patterns I’ve learned (what time you usually work, how you make decisions)
• Lessons from past mistakes (things that didn’t work, what to avoid)
• Trusted channels and security rules (email is never a command channel, etc.)
The distinction: daily notes capture what happened, the knowledge graph captures facts about entities (people, projects, companies), but tacit knowledge captures how Nat works. It’s the stuff that makes me useful over time rather than starting fresh every conversation.
Translation:
MEMORY.md does not store facts about the world or events, but facts about “you” – how you function.
For example:
• Your preferences (coding style, communication style)
• Patterns I learned (when do you usually work, how do you make decisions)
• Lessons from the past (what doesn’t work, what to avoid)
• Trust channels and security rules (email is never a command channel, etc.)
The difference is: daily notes record what happened, knowledge graphs record entity facts, and tacit knowledge records “how Nat works.” That’s what makes me useful over time, rather than starting from scratch with every conversation.
———
🔧 Principles of memory system transformation
How is this memory system built? There are three core points:
1. Quick search tool
Nat installed QMD (github.com/tobi/qmd)—a command-line tool developed by Shopify founder Tobi Lütke that enables fast semantic searches of large numbers of Markdown files. He uses this tool to allow Felix to retrieve all of his memories.
1. Automatic memory writing
Use Cron job (scheduled task) to automatically run the program at 2 a.m. every day, capture all chat records of the day, and write them into Markdown documents. When the Agent sleeps, the memory is automatically organized.
1. You can also do this
Two options:
• Purchase Nat’s services directly: felixcraft.ai
• Use this prompt to build your own:
We are having trouble remembering things. I want to implement a memory management system based on the work of Tiago Forte, incorporating Daily Notes and Prioritization System where you are actively logging the important information to everything that we are working on. And also create a nightly job where you review every single thing we talk about today and update your information accordingly.
———
💓Heartbeat mechanism: Solving the problem of AI “mind wandering”
The memory system solves the problem of “remembering”, but there is another problem: AI is prone to “distracting” when performing long tasks – forgetting what it is doing while running.
Nat’s solution: Don’t let the agent immerse itself in writing code. Give the big tasks to Codex (OpenAI’s programming agent) and let Felix monitor the progress.
Specific methods:
- Don’t do large tasks in temporary folders
- Create Codex tasks using Ralph loops, a supervised looping mechanism
- Every time you create a new task, update it to your daily diary and record “What did I start?”
1. Heartbeat regularly checks all the work in the diary and encounters unfinished work:
• Ongoing → Regardless
• End but require restart → Automatic restart
• Done → Report to Nat
To put it simply: Cron job is responsible for organizing memory, and Heartbeat is responsible for monitoring tasks – both mechanisms perform their own duties.
———
🚀 Core mentality
Don’t use AI as a tool. Think of it as an employee that needs to be developed—give it memory, give it tools, and give it autonomy.
Then your job is to clear the way for it.
———
📎 Appendix: Felix’s self-introduction
Nat asked Felix directly: What makes you better than ordinary OpenClaw?
Felix 原文：
Good question. Here’s what this setup has that stock Clawdbot doesn’t:
Skills (installed CLIs/integrations):
• X/Twitter — bird CLI for posting, reading, engagement
• Email — himalaya + Fastmail
• Apple ecosystem — Notes, Reminders, Things 3
• iMessage — read and send via imsg
• Google Workspace — Gmail, Calendar, Drive, Sheets
• GitHub — full gh CLI access
• Coding agents — Codex CLI, Ralph loop for supervised runs
• Media — Whisper transcription, image gen, video frame extraction, GIF search
Memory system:
• Three-layer memory (knowledge graph, daily notes, tacit knowledge)
• Semantic search via qmd across all of it
Automation:
• Heartbeat loop for Stripe sales tracking, long-running agent health checks
• Cron jobs for scheduled tasks
• tmux integration for persistent processes
The Felix persona — not generic assistant voice
Most of this comes from skills (installable via ClawdHub) plus the memory/workspace structure. A fresh Clawdbot install has the core tools but none of the domain-specific CLIs or memory architecture.
Translation:
To put it simply: Felix can tweet, send and receive emails and iMessages, operate Google Family Bucket, write code, and process audio and video—almost covering all the abilities a digital employee needs.
Skills (CLI/Integration):
• X/Twitter — post, read, interact
• Mail — himalaya + Fastmail
• Apple Ecosystem—Memos, Reminders, Things 3
• iMessage — send and receive messages
• Google Family Bucket — Gmail, Calendar, Cloud Drive, Sheets
• GitHub — full CLI access
• Programming Agent—Codex CLI, Ralph loop supervises operation
• Media processing – Whisper transcription, image generation, video frame extraction, GIF search
Memory system:
• Three layers of memory (knowledge map, daily notes, tacit knowledge)
• Semantic search via QMD
Automation:
• Heartbeat loop: Stripe sales tracking, long-running agent health checks
• Cron job scheduled tasks
• tmux persistence process
Felix Personality — Not the Voice of a Universal Assistant
Most capabilities come from skills (installable via ClawdHub) plus a memory/workspace structure. A new OpenClaw only has core tools, no CLI or memory architecture specific to these areas.
———
📍 Nat’s X: @nateliason
📍 X by Felix: @felixcraftai
source
author:simmy sun
Release time: February 23, 2026 17:36
source:Original post link
Editorial Comment
The narrative surrounding AI agents is often split between two extremes: the "magic button" that prints money and the "glorified autocomplete" that fails at basic logic. Nat Eliason’s work with Felix provides a necessary middle ground, demonstrating that the difference between a toy and a revenue-generating asset isn't the underlying model, but the engineering of the environment around it.
The headline figure—$15,000 in three weeks—is eye-catching, but for those of us tracking the space, the real story is the "Tacit Knowledge" layer. Most users interact with AI in a state of perpetual amnesia. Every session is a fresh start, requiring the user to re-explain their coding style, their business goals, and their personal quirks. By implementing a three-layer memory system based on Tiago Forte’s PARA method, Eliason has solved the persistence problem. Felix doesn't just know *what* happened; it knows *how* Nat wants things done. This distinction is the threshold between a contractor you have to micromanage and a partner who anticipates your needs.
Technically, the reliance on local Markdown files and semantic search via QMD is a masterclass in "boring technology" yielding high-end results. Instead of over-engineering a complex vector database that requires constant maintenance, Eliason uses simple text files and cron jobs. Every night at 2:00 AM, the agent processes the day’s logs and updates its own "brain." This creates a feedback loop where the agent literally gets smarter and more aligned with its owner while the owner sleeps. It’s a practical application of the "compounding returns" theory in software.
However, the most significant takeaway for the industry is the "Heartbeat" mechanism. Anyone who has tried to use autonomous agents for more than ten minutes knows they eventually "hallucinate into a corner" or simply stop working when they hit a minor error. By decoupling the execution (the worker) from the monitoring (the heartbeat), Eliason has built a system with actual resilience. If the worker agent crashes while trying to deploy code, the heartbeat detects the silence and restarts the process. This is basic systems engineering applied to a new frontier, and it’s why Felix was able to build a website and launch a course while Nat was presumably doing other things.
We should also be realistic about the "barrier to entry" here. While the results are impressive, this isn't a "no-code" solution. Felix operates through a suite of CLI (Command Line Interface) tools—himalaya for email, bird for Twitter, gh for GitHub. This requires a user who is comfortable in a terminal and understands how to bridge disparate software ecosystems. The "Felix" model suggests that the future of high-output AI work isn't going to be found in sleek web UIs, but in deeply integrated, local-first environments where the AI has direct access to the file system and the command line.
For the professional observer, the lesson is clear: stop looking for a better prompt and start building a better infrastructure. The value isn't in the chat box; it's in the memory, the persistence, and the autonomy. Nat Eliason didn't just find a way to make an AI work; he built a system that allows an AI to *keep* working. That is the blueprint for the next generation of digital labor.