For Artur & Girlfriend — prepared by Claude, based on Alfonso's month of agent-building learnings so you can skip the hard parts.
A personal AI agent that lives on your laptop, talks to you through a messaging app, and remembers your preferences over time. Think of it like having a quirky assistant that can search the web, manage files, and do tasks on its own schedule.
The platform is called OpenClaw — it's open source, runs locally, and gives you a real agent (not just a chatbot). You'll connect it to an LLM API for the brain, a messaging app for the interface, and optionally give it skills, memory, and a personality.
The best part: OpenClaw supports multiple agents on one laptop. So you can each have your own agent — with its own name, personality, memory, and connected tools — all running from the same gateway. More on that later.
OpenClaw — the agent platform. Runs on your laptop as a local gateway. It handles the agent loop, memory, skills, heartbeat (autonomous behavior), and messaging integrations. Install it, configure one JSON file, and you're running.
An LLM API — the brain. This is the service your agent calls to think. You'll need an API key from a provider. There are two ways providers charge: flat-rate plans and per-token pricing. Here's the difference.
An API (Application Programming Interface) is how your agent talks to the AI model. When you send a message to your agent, it packages that message and sends it over the internet to a service (like MiniMax or Google), which runs it through a large language model and sends a response back. The API is the door your agent knocks on. You get an API key (basically a password) that lets your agent access the service.
Tokens are the units AI models use to measure text. Roughly, 1 token is about 3/4 of a word. "Hello, how are you today?" is about 7 tokens. Every message you send costs input tokens, and every response costs output tokens.
Flat-rate plans (like MiniMax Coding Plans) give you a fixed number of prompts per time window for a monthly fee. You don't think about tokens — you just send messages until you hit your limit, then wait for the window to roll over.
Per-token pricing (pay-as-you-go) charges you based on exactly how much text goes in and out. Cheaper if you use it lightly, but costs can add up if your agent is doing a lot of autonomous work.
For a personal project, flat-rate is simpler to reason about. You know exactly what you're spending.
MiniMax is an AI company (based in China, strong models) that offers flat-rate Coding Plans: $10, $20, and $50/month tiers. The $10 Starter gives you 1,500 model requests per rolling 5-hour window — that's a lot of back-and-forth with your agent throughout the day. The rolling window means your oldest usage "falls off" over time, not a hard daily reset.
Their model is MiniMax-M2.7, which runs at around 50 tokens per second normally and up to 100 TPS during off-peak hours. It's OpenAI-compatible, which means most code examples and tools just work with it out of the box. The plan also includes image understanding and web search MCP (a protocol that lets your agent use external tools).
Alfonso currently uses MiniMax at $20/month for heavier workloads. $10 is a great starting point — you can bump up later if you want to give your agent more autonomous work.
Google offers free Gemini API access through AI Studio (aistudio.google.com). No credit card required. You sign up with a Google account and get an API key immediately. The free tier gives you access to models like Gemini 2.5 Pro with a massive 1-million-token context window.
The rate limits on the free tier are modest (5-15 requests per minute depending on the model, 100-1000 per day), but that's more than enough for getting started and experimenting before committing to a paid plan.
OpenClaw can run multiple fully isolated agents inside one gateway process. You don't need two laptops or two installs — you run one gateway, and it hosts two separate "brains" inside it.
Each agent gets its own:
So Artur's agent could be connected to his WhatsApp, and his girlfriend's agent to hers. Or you could both use Telegram with separate bots. Each agent has its own personality, its own memory, and its own set of tools.
This is where it gets interesting. Each agent can have different skills and integrations. For example:
The agents don't share memory or context unless you explicitly tell them to. They're fully independent.
This is especially relevant for Artur given his FP&A background. Google Cloud Console ($300 free credits per new project) isn't just about Gemini API calls — it's a gateway to Google's entire cloud platform:
The $300 in free credits covers a lot of experimentation with these services. And since each Google account gets its own API credentials, this naturally supports the "one agent per person" setup — each agent authenticates as a different user and sees only that user's data.
How you talk to your agent. OpenClaw supports several:
Use whatever you already have. The messaging layer is just plumbing. If you're running two agents, you can use the same platform with two separate bot accounts, or different platforms entirely.
Use GitHub from day one. Here's why:
Your agent's config, personality, and skills are all text files — they are your project. Git tracks every change, so when you tweak the personality and it gets weird, you can roll back in one command.
You'll change the personality 10 times the first weekend. Without version control, you'll lose the version that worked.
Two people, one project. You and your girlfriend can both make changes without overwriting each other. Git handles the merge. Without it, you'll be texting "don't touch the config file, I'm editing it."
It's free — private repos, unlimited. And it's your backup. Laptop dies, agent lives on GitHub. Clone it onto a new machine and you're back in 5 minutes.
You don't need to be a git expert. Learn git add, git commit -m "message", git push, and git pull. That's 95% of what you'll use.
These are the learnings from Alfonso's month of building and iterating on agents.
OpenClaw uses a file called SOUL.md — it defines who your agent is. Tone, style, boundaries, how it talks. This is the single most impactful file in your whole setup. Spend time on it. Write it together — it's actually fun.
A good SOUL.md has:
OpenClaw has built-in memory — your agent remembers past conversations and can search through them. This is what makes it feel like your agent instead of a generic chatbot. It works out of the box with local embeddings (no extra API cost).
Put a few files in its workspace: notes about yourselves, things you care about, project context. The agent will search these when relevant. The more context it has, the better it performs.
OpenClaw has a skill system — small capability packages your agent can use. There's a built-in set plus a community hub (ClawHub). Start with the defaults, then add what you need: web search, file management, scholarly search, or build your own (a skill is just a markdown file describing what the tool does).
The "heartbeat" is OpenClaw's mechanism for your agent to do things on its own — check in, reflect, run scheduled tasks. You can set it to send a morning briefing, do an evening reflection, or proactively work on things you've assigned.
Start simple: maybe a morning message and an evening summary. You can make it more autonomous later.
Things Alfonso spent time on that you should skip:
Don't optimize retrieval weights. Alfonso literally wrote a research paper on this. For a personal agent, the defaults are fine. The agent can just search again if it doesn't find what it needs.
Don't over-engineer the architecture. Alfonso's first system was 19,000 lines of Python across 34 files with 18 background services. His current setup does more useful work with ~800 lines and 1 service. Start minimal. Add complexity only when you feel the pain of not having it.
Don't use Docker unless you already love Docker. It eats 2-4GB of RAM for no reason on a personal laptop. OpenClaw runs natively.
Don't stress about the "best" model. MiniMax M2.7, Gemini, Claude — they're all strong enough for a personal agent. Start with whatever's cheapest and easiest, and you can swap models later since OpenClaw makes it a one-line config change.
Here's a loose plan for when you two sit down to do this. No rush — the whole point is to have fun with it.
Session 1: Get it running (2-3 hours)
1. Install OpenClaw on the laptop (follow their docs, it's straightforward)
2. Sign up for MiniMax Starter ($10/mo) or grab a free Gemini API key from AI Studio
3. Get the API key, put it in your OpenClaw config (openclaw.json)
4. Set up your messaging bot (WhatsApp or Telegram)
5. Send your first message — confirm it responds
Session 2: Make it yours (2-3 hours)
1. Write your SOUL.md together — give your agent a name, personality, vibe
2. Create a USER.md with context about both of you
3. Add a few skills from ClawHub
4. git init and push to a private GitHub repo
5. (Optional) Set up the second agent with its own workspace and messaging binding
Whenever you feel like going deeper:
1. Set up a morning briefing cron job
2. Add some files to the agent's memory (notes, preferences, project ideas)
3. Start a conversation thread and see how it remembers context
4. Tweak the personality based on how the first few days felt
Your main config file is openclaw.json. The key fields:
{
"models": {
"default": "your-model-name"
},
"messaging": {
"telegram": { ... }
},
"heartbeat": {
"every": "6h"
},
"memory": {
"enabled": true
}
}
The workspace directory (~/.openclaw/workspace/) is where your agent's personality and memory files live: SOUL.md, USER.md, MEMORY.md, HEARTBEAT.md. These are the files you'll edit most.
For multiple agents, each agent gets its own workspace under ~/.openclaw/agents/ — same file structure, fully isolated.
Hard-won insights from Alfonso's build that'll save you time:
Frameworks add more complexity than they solve at your scale. Alfonso ripped out an agent framework and replaced it with 280 lines of direct API calls. The result was simpler, faster, and easier to debug. OpenClaw already IS your framework — don't add another one on top.
Commit your config changes before experimenting. git commit -m "working personality v3" before you start tweaking. You'll thank yourself.
If you change a config file, restart the gateway. The number one "bug" is editing a file and wondering why nothing changed. The running process still has the old version.
Set token limits generously. If your agent's responses are getting cut off or it's doing weird multi-step loops, your max_tokens is too low. 16,384 is a safe default. Too low causes truncation cascades that cost MORE tokens, not fewer.
Temperature 0.3 for utility, 0.7+ for creativity. Lower temperature = more focused, shorter responses. Higher = more creative but verbose.
Your agent will be bad at first. That's normal. The personality takes iteration, the memory takes time to build up, and you'll learn what instructions actually stick vs. what gets ignored. Give it a week of daily use before judging.
Prepared by Claude, drawing on Alfonso's experience: a month of agent engineering, 10,000+ agent iterations, 4,500+ task episodes, and a published research paper on retrieval optimization. Compiled so you can skip straight to the fun part.
(March 2026)