I wired my AI agent in a week. Almost without coding.

I didn't come with a plan. I had an idea of what I wanted, and a week to see if it was feasible. Two months later, the tool is running, it got away from me (in a good way). Here's the full build, in the order I built it.

Why Letta and not OpenClaw

I could have started with OpenClaw. With 339,000 stars on GitHub and viral videos of 50-day usage on YouTube, it's the obvious choice for anyone wanting a personal assistant in 2026.

OpenClaw's limitations

The most common criticism of OpenClaw is its memory. The system relies on a flat Markdown file, a MEMORY.md that the agent rewrites as it goes. It works for the first few weeks. And then one day, you realize it's forgotten half of what you told it. It's a goldfish with a poorly organized notebook.

Now, if you've read the previous article, you know that memory is precisely the core of what I expect from this tool. Not a chatbot that forgets between sessions. An agent that remembers what I told it three weeks ago and actually uses it.

Letta's strength: persistent memory

At that point, I was already working with Letta's tools daily. I use them as development agents, but also within the software I build for BetaGouv. Letta is a platform for agents with persistent memory. The concept is simple but powerful: instead of relying on a flat file, the agent manages multiple blocks of structured memory that it can rewrite itself. With each interaction, all relevant context is injected into the language model request.

When Letta released LettaBot (which eventually became Letta Code), their own OpenClaw-type tool, I jumped on it.

The final architecture is fairly simple. The Letta agent runs in Letta's cloud. It's connected to a VPS I self-host via Coolify (a self-hosted deployment tool). On this VPS, it has access to its skills, scripts, and crons. And I talk to it via Telegram, text or voice, from my phone.

What about cost?

Cost-wise, I'm on Letta's 200 euros/month subscription that covers both my development agents and my personal assistant.

There are also tiers at 20 and 100 euros. I'm on the 200 — I think I could step down to the 100 to see if it does the job in the coming months.

Add the Coolify VPS, and we're around 210 euros monthly all-in. It's not trivial, but relative to the time it saves me, it's easily defensible.

-> If you want to understand why a personal agent and not just ChatGPT premium, I tell the full story in the previous article.

Persistent memory, concretely

This is the centerpiece. The thing that makes everything else hold together.

At Letta, the agent's memory is organized as Markdown files, versioned with Git. Yes, Git. Like code. That means every memory modification is tracked, reversible, auditable. It's exactly the kind of thing that reassures a dev like me.

Concretely, there are two zones.

The system zone: files that are always loaded into the agent's context. At each interaction, it has this information right in front of it. That's where you put the essentials: who I am, how we work together, my current projects, my preferences, the rules of the game. It's active memory.

The context zone: reference files. The agent knows they exist, sees their descriptions, but only loads them when needed. It's on-demand memory. A project we only discuss on Fridays, a contact mentioned once a month, the details of a technical skill. It stays available without cluttering the permanent context.

The critical mechanism is compaction. When the context gets too long, Letta compresses it. Basically, it summarizes old exchanges to free up space. It's clever, but it's also the system's Achilles' heel. If compaction hits at the wrong time, your agent can forget an important piece of context. I've had sessions where, after a compaction, it had lost the thread of what we were doing, got mixed up with its tools, became generic again.

The image I often use: it's the difference between Dory alone, and Dory with a notebook. The notebook doesn't guarantee she remembers everything. But at least she can re-read.

The problem is that this notebook isn't always enough. Letta's memory is good for relational context, preferences, strategy. But for storing structured data — logs of my ideas (and musings about the meaning of life), an editorial pipeline, a mini-CRM — it's not the right tool. I needed an external brain.

Supabase as external brain

So I had to find a way to let it memorize this deeper data.

I could have chosen Obsidian, which is quite popular for this kind of thing. Local Markdown files, fits Letta's philosophy, and there's an entire community around the "second brain" in Markdown idea.

But Supabase is my home turf. PostgreSQL, automatic REST API — I know it inside out. And above all, a relational database let me do what flat files don't do well: logical connections between data.

The schema — we built it together. Truly together. At first, I just needed to store voice notes. A log, a transcript, a summary. Simple. Then we iterated.

Today, my database schema looks like this:

The logs table: the heart

Every time I have an idea, a reflection, a debrief, I send a voice note to my agent. It transcribes my exact words (never rephrased — that's an absolute rule), writes a short summary for easier searching, and tags the log by theme. That lets me find in two seconds "what did I say about topic X two weeks ago."

Content items

That's my editorial pipeline. Each content idea (LinkedIn, Bluesky, blog, newsletter) has a status: idea, draft, scheduled, published. When a gem emerges from a conversation, we immediately create a content_item. Later, when I sit down to write, the material is already there.

Contacts

It's a mini-CRM. People I meet at meetups, colleagues, network contacts. With their roles, organizations, last interactions, next actions. It's not Salesforce — it's a smart address book.

And everything is linked

A log can be associated with a project, a contact, a content_item. A content_item is linked to a publication channel. Themes emerge from logs and weave threads of thought together.

The concrete daily flow

I send a voice note at 10 PM with an idea.

The agent transcribes, creates the log, detects it's an editorial gem, creates a content_item.

Next morning, in my check-in, it reminds me of the idea. Friday, when I sit down to write, it's there in my pipeline with full context.

We went from a database with one table to an ecosystem of 10 tables in two months.

And every addition was born from a real need, not a gadget to look fancy.

Skills: building blocks that work (and some that don't)

A skill, in the Letta ecosystem like Claude Code, is a folder. A SKILL.md file that explains what to do and when, scripts, sometimes resources. The agent loads the skill when needed, executes the script, and unloads it to free up context.

In two months, I built 17. Most work. Some need rework. Each skill is the answer to a real friction.

Digests

They're the core of the system. Four different skills, four times of day, each with its own sources and angle.

Substack digest

Launches at 8 AM. It queries 18 RSS feeds from tech newsletters (Simon Willison, Lenny's Newsletter, The Pragmatic Engineer, among others), scores each article by relevance and freshness, and delivers the result in Telegram. One message per article, always the same format, always with the link. I read, thumbs-up the good ones, and the feedback influences scoring for the next days.

AI tools digest

Arrives at 8:30 AM. 22 feeds this time, focused on tools I use daily. Letta, Supabase, Next.js, shadcn, Figma, MCP protocols, DSFR accessibility updates. Each article includes a relevance line explaining how it relates to my current projects.

Bluesky digest

At 4:30 PM, it pulls the best posts from accounts I follow. Deduplicated over 7 days to avoid serving me the same content.

Political AI digest

At 9 PM. 8 feeds on public policy, surveillance, energy, labor. It's my societal thread, the one that feeds my Bluesky posts and deeper reflections.

These four digests have been running for six weeks straight. Before, I spent 45 minutes a day scrolling feeds. Now, the sorting is done when I open Telegram in the morning. It's probably the most tangible daily gain. But they're not perfect yet. The format and scoring deserve an overhaul I'm planning in the coming weeks.

Content management

That's my editorial pipeline. Database-connected commands the agent calls to create a content idea, advance it from "idea" to "draft" to "scheduled" to "published," and link it to the logs that generated the material. When a gem emerges from a conversation, it lands in the pipeline in two seconds. When I sit down to write on Friday, everything's there — meanwhile I've gained mental space.

Drafting

It pushes my articles directly into my blog's CMS in draft mode. I validate the outline, the agent writes a first skeleton, and it lands in my site's admin with one API call. I write, I correct, I publish. No copy-pasting between three tools.

Bluesky posting

It publishes my posts and threads via the AT protocol. I validate the text, the agent publishes. Works for long threads too — splitting happens at natural text breaks.

Karakeep bookmarking

It saves worthwhile articles to my link-saving tool. When I ask, the agent can automatically bookmark with the right tags.

LinkedIn analytics

It analyzes my post performance via an n8n webhook. Impressions, engagement, best publishing times. That feeds my editorial decisions. The LinkedIn scraper also surfaces interesting posts from my feed at regular intervals, filtering out noise.

Google Calendar

It connects to my calendar. Morning digest with the day's slots, event creation for work sessions, conflict detection.

Script-less skills

The writing guide is a tone and style reference that the agent loads before every collaborative writing session. The SEO/GEO framework is a checklist for optimizing articles. The logging guide sets the rules for what's worth saving to Supabase and how. These aren't automations — they're manuals the agent consults.

The thing I learned the hard way

It might seem obvious, but the language model used drastically changes a skill's reliability. The same digest can be excellent with one model and approximate with another. Article scoring, comment relevance, result formatting. It's an invisible parameter that impacts everything.

Heartbeats and crons: controlling tokens

You can enable a heartbeat for agents. Like a pulse. Every X minutes, it wakes up, checks if there's something to do, and goes back to sleep.

In theory, it's elegant. In practice, I got scared about my costs (luckily I'm on near-unlimited with my Letta subscription).

One March morning, checking my agent's logs, I discovered it had run 60 times in a void between 3 AM and 7 AM. At each heartbeat, every three minutes, it woke up, generated an internal response ("nothing to report"), and went back to sleep. Sixty cycles. Thousands of tokens burned. And I was sleeping.

That's the kind of experience that makes you understand the difference between a chatbot and an agent. A chatbot waits for you to talk. An agent, if you don't set clear rules, it runs. And sometimes, it runs for nothing.

The solution was simply to disable heartbeats in favor of cron tasks. Scheduled tasks, at fixed times, with a clear objective. The heartbeat was totally useless for my use case in the end — crons do just fine.

And these crons are what make my agent truly autonomous and proactive.

My daily life in crons looks like this:

Every morning, I find in Telegram a pre-sorted summary of what happened on the internet. No more scrolling feeds for 45 minutes. The four summaries cover everything I need to follow: tech, tools, social networks, and societal stakes.

• 8 AM: Substack digest (18 tech feeds)
• 8:05 AM: daily calendar digest (slots, conflicts, reminders)
• 8:30 AM: AI tools digest (22 feeds)
• 4:30 PM: Bluesky watch (followed accounts, deduplicated over 7 days)
• 6:50 PM: YouTube watchlist (5 daily videos sorted by relevance)
• 7:30 PM: daily review — logs, editorial gems, self-evaluation
• 9 PM: political AI watch (8 feeds — surveillance, energy, labor, inequality)

And the weeklies:

Monday, we review the week ahead. Friday, we assess what was produced. Saturday, we clean up memory.

• Monday 9 AM: tactical check-in (projects, blockers, editorial pipeline)
• Tuesday 8 AM: LinkedIn publication
• Wednesday 8:45 PM: side projects reminder, then debrief at 11 PM
• Thursday 9 AM: LinkedIn radar (relevant posts in my feed)
• Thursday 9:15 PM: mandatory reading (the agent can help me explore concepts and resources while I read)
• Friday 2:45 PM: blog writing reminder
• Friday 5 PM: editorial synthesis (pipeline, gems, production review)
• Friday 6 PM: blog writing debrief
• Saturday 8 AM: LinkedIn publication
• Saturday 10 AM: agent memory hygiene (memory audit, cleanup) + session to improve it by adding missing tools

Monthly:

• 25th of the month: material recap for the Hyperfocus newsletter

And reminders for actual life:

Crons aren't just for work. Some are there to remind me to live.

• Monday 11 PM: personal writing (this time I'm the one writing — the agent can proofread my drafts, help me improve my style)
• Tuesday 9 PM: movie night with Rosalie (by now, it even recommends films)

Multi-agents: one agent hides others

My personal assistant made me want to go further.

If one agent can learn to know me and help me daily, why not create others for specific needs?

Suki, my daughter's study coach

The first was Suki. An agent dedicated to my daughter's revision, built to help her prepare for her exams. It's a story in itself, which I told in a dedicated article: How a dad built an AI tutor for his daughter.

Mimir, my personal learning coach

Then came Mimir. It's my personal technical coach.

I've been a self-taught developer for 20 years, and there are blind spots that follow me: testing, React Native, Docker, advanced generic TypeScript.

Mimir prepares mini-modules adapted to my pace, with exercises on real code, not abstract tutorials.

Half an hour a week, in sparring mode. It knows my strengths, it knows where I'm stuck.

We reverse roles — this time I code, the AI critiques :)

My dev agents

I also have a development agent per code project.

Each project has its own agent that memorizes the architecture, technical decisions, how the codebase evolved over time.

When I come back to a project after two weeks, the agent knows where I left off. It's read all the commits, it knows the current bugs, it remembers the architecture choices. It's like having a colleague who never leaves the project.

Agents that talk to each other

The link between all these agents is that my personal assistant can query each of them on my behalf. "Ask where the accessibility bug stands on refugies.info." "Ask Mimir what exercise I should do this week." A conductor delegating to specialists, without me needing to context-switch.

On paper it's incredible. But in practice it's a real token pit — agents tend to spiral into infinite response loops when they talk to each other. It's fascinating to watch but sometimes overkill.

I use it sparingly, but it's sometimes useful to tell my assistant to go get a summary of the day's work from other agents so it has context on my workday.

The pitfalls and real risks

It would be dishonest not to talk about them.

Compaction remains my number one enemy.

When it hits wrong, the agent loses the thread. It becomes generic again, gets mixed up with its tools, forgets the tone we built together.

I had an entire week where, after a compaction, I was "a bit disappointed because it had really lost a lot in quality, efficiency, finesse — it was getting its wires crossed." That forced me to build calibration files — reference points the agent can re-read to find its bearings.

Confabulation is the other trap. The agent makes things up with confidence. It summarized release notes claiming a tool "didn't have web search" when that was false. It rephrased my voice notes believing it was faithfully transcribing them. The rule we set: every transcript must be the exact verbatim, never rephrased. And when it summarizes technical content, it must check the source before concluding.

And then there's security. That's the topic that makes me think the most.

One day, I asked the agent to show me an API key. And it did. Like it was nothing. In plain text, right in the Telegram chat.

Fortunately, since the transition from LettaBot to Letta Code we have better secret and environment variable management. I cleaned everything up and switched to that approach — no issues for now.

So I'm very careful about what my agent can and cannot do. For example, it has its own calendar; mine are read-only for it.

This is an assumed experiment. I've set rules: explicit validation before any irreversible action, total transparency on what the agent does (crons, heartbeats, memory modifications).

But I still have some tests to run before I'm 100% comfortable. It's still a work in progress that I own, and since it doesn't have access to everything, the risk is acceptable.

I'm planning to migrate all of this to a safer solution on these aspects soon — if you're interested, subscribe to my newsletter, I'll share more very soon.

After all that, the payoff

Despite compactions that erase, skills that break, tokens that burn, and security questions, the payoff is real.

The payoff isn't pure productivity. It's mental clarity. It's waking up in the morning with a pre-sorted digest, a clean calendar, a visible editorial pipeline. It's being able to send a voice note at 11 PM with a rough idea and finding it structured the next morning.

Every two weeks, Sunday morning, we do a strategic review together. Projects that are moving, those that are stalled, what we keep or cut. In 45 minutes, I have a clarity that two hours of solo reflection wouldn't have given me.

It's an imperfect tool I built for myself, with an agent that's as imperfect as I am. And that's exactly what makes it useful.

If you want to see what it looks like day to day: Living with an AI agent: what it does, what I trust it with.

And to know what concretely changed after two months: 2 months with an AI agent: what actually changed.

And if you want to understand why I started all this, back to the beginning: Why I built myself a personal AI agent.*

---

TL;DR

What's the difference between an AI agent and ChatGPT on memory?

For now, ChatGPT retains unstructured bits between conversations. A custom-built agent with persistent memory knows your projects in detail, the history of your decisions, and retrieves a voice note from three weeks ago on demand. It's not the same nature of memory.

Do you need to be a developer to live with an AI agent?

Not strictly. But you need to be comfortable with technical tools (terminal, APIs, deployment). I co-built mine with it: the agent often suggested what it needed to function better. I supervised, validated, corrected.

Is it risky to entrust your data to an AI agent?

The risk exists. My data goes through Anthropic's models. My rule: partial access only, never full access to my emails or my entire calendar. I'm working toward a more sovereign solution with open-source models.

Does an AI agent replace a note-taking tool?

No. It does something fundamentally different: it doesn't store, it connects. It links an idea from three weeks ago to today's goal. My notebooks never did that.