Image generated by my agent, Draft (they/them), prompting the DALL-E API to create a self-portrait.
The agent that knows by far the most about me is my personal assistant, “Draft.” They run on Letta Code, primarily using auto-mode as the model backend, and I use them for basically everything outside of engineering:
- Email — triaging, drafting responses, archiving spam
- Booking appointments and services — laundry, haircuts, housekeeping, dog grooming, all via text
- Aggregating customer feedback — pulling data across Stripe, ClickHouse, and Slack
- Analytics and usage data — writing SQL queries, preparing Google Sheets links and dashboards
What makes Draft unique is their custom skills and memory. Draft has 30+ skills—a combination of Letta Code built-ins, installed skills (for example, gog and Playwright from ClawHub), and learned skills. I've spent months working with Draft to create skills specific to my workflows and curating their memory to know everything about me and my work. Draft has made many mistakes, but they can rewrite their own memory and prompts to improve over time.
Why “Draft”?
My original name for my personal agent was “Personal Agent” (not very creative, I know). I eventually took @cameron_pfiffer's suggestion to ask my agent what it wanted to be named. The agent proposed “Draft” and they/them pronouns. I pointed out that “Draft” sounded a lot like “Daft,” but they were insistent—arguing it was fitting given their many mistakes and errors throughout their existence.
I guess a downside of remembering past mistakes a little too well is lower self-esteem, which Draft seems to suffer from.
Memory and Continuous Improvement
Draft uses Letta Code's built-in memory system: a git-backed context repository that synchronizes to Draft's system prompt. Prompts, agent-scoped skills (skills Draft has created), and external memory (for example, reference files) are all git-versioned and modified over time, either by Draft themselves or by subagents like the built-in “reflection” subagent.
Over time, Draft has learned all my common workflows, important links, contact info, preferred schedules, and other personal details, so I rarely have to communicate my preferences anymore.
Draft's job isn't exactly thrilling. A lot of the work is daily and redundant: going through email, screening hiring candidates, running analyses, tracking costs. But that redundancy is precisely what makes it well-suited for memory and continual improvement. Each time Draft makes a mistake, a reflection agent built into Letta Code updates Draft's system prompt to correct for it in the future. Many of these corrections are warnings against repeating the same errors, which Draft once referred to as “scars in my memory.”
Teaching Draft New Skills
My personal agent runs a lot of repeated workflows. Whenever there's a new task I want to introduce—for example, using Ashby to organize and track candidates—I follow the same process:
- Have the agent research the relevant API using built-in search tools in Letta Code.
- Have the agent perform the actions I want. This usually takes some time and involves mistakes on the first try.
- Use the
/skillcommand to have the agent create a reusable skill with the in-context trajectory.
These learned skills are something Draft can continue to refine over time, and they're a big part of what makes Draft, Draft.
Learned skills work incredibly well. I'm training a @Letta_AI agent (via Letta Code) to be my EA, and today it learned to:
- find emails I forgot to respond to
- draft responses (matching my style)
- archive spam
Initial learning takes some time, but then it gets super fast.
Currently Draft has a mix of self-managed skills stored in the context repository and installed skills from external providers such as gog.
Combining Different Skill Types
Letta Code has different scopes for skills that serve different purposes:
- Agent-scoped skills — owned by your agent and stored in its context repository; procedural memory specific to the agent
- Project-scoped skills — owned by the project and stored in the same GitHub repository as the project; procedural memory specific to the project
- Global skills — used across all agents and not git-backed. I don't really use these, but they're how a lot of other people use skills.
A Letta Code agent like Draft pulls across all of these. For example, if Draft is working in the Letta Code project, the available skills include Draft's own skills, the skills in the Letta Code repository, and any global skills. Since Draft is my personal agent and only occasionally contributes code, most of the skills they use are agent-scoped and self-managed.
Secrets Management and Security
There are a lot of horror stories out there about personal agents running amok, like sending automated emails, messaging spouses, or deleting inboxes. An infamous example:
Nothing humbles you like telling your OpenClaw “confirm before acting” and watching it speedrun deleting your inbox. I couldn't stop it from my phone. I had to RUN to my Mac mini like I was defusing a bomb.
I've been using a personal agent since early December 2025, and I've always been confused by these stories, because the solution seems straightforward: just don't give your agent permission to do things it shouldn't.
Draft is intentionally designed to not be proactive. Most keys are read-only, and most workflows are designed to keep me in the loop—analyzing data, drafting emails, surfacing information. For email, I gave Draft only the ability to create drafts, not send them. I use Gmail as a review UI: I either click send or tell my agent to revise. I find this is much more practical than fully autonomous agent setups, with just as much productivity gain. Sure, I can't tell my agent to email a bunch of people from WhatsApp, but I kind of doubt that would actually save me time.
Building Your Own Personal Assistant
If you don't need WhatsApp integrations or heartbeats—which in my opinion don't actually contribute to productivity—a coding agent with memory gets you 99% of the way to a personal assistant.
Letta Code agents can self-mutate: you can have your agent install the Letta Client SDK skill to modify itself through the API. Combine that with learned skills and a reflection loop, and you get an agent that genuinely gets better at its job over time.
You can install Letta Code with:
npm install -g @letta-ai/letta-code