Back to Blog

I Gave My AI Agent Access to My Life — Here's What Happened

February 24, 2026 Tools 11 min read 0 views
OpenClawAI AgentsWhatsAppAutomationProductivityDeveloper Tools

It Started as a Weekend Experiment

I was scrolling through GitHub Trending on a Saturday morning when OpenClaw caught my eye. An open-source AI agent that lives in your chat apps? Not another chatbot with a fancy web UI—an actual agent that uses your WhatsApp, your iMessage, your browser. One that can run shell commands on your machine, browse the web for you, and—here's the part that got me—proactively text you when something needs your attention.

"That sounds either amazing or terrifying," I thought. I decided to find out which one.

What followed was one of the most interesting weeks I've had as a developer. Not because of some breakthrough feature I shipped, but because my relationship with my tools fundamentally changed. I stopped going to my AI assistant. It started coming to me.

What Is OpenClaw?

Before I get into my setup, a quick overview for the uninitiated. OpenClaw is an open-source, local-first AI agent framework. It runs on your machine, connects to an LLM provider of your choice (I use Claude), and communicates with you through your existing messaging apps.

The key distinction: this is not a chatbot. It's an agent with tools. It can:

  • Execute shell commands on your machine
  • Control a Chrome browser instance via CDP (Chrome DevTools Protocol)
  • Read and write files
  • Access your calendar
  • Run scheduled tasks via cron
  • Proactively reach out to you through heartbeat checks

Think of it as a teammate who happens to live in your group chats—except this teammate never sleeps, has perfect memory of what you asked three days ago, and can actually go do things on your computer while you're at the gym.

The Setup: WhatsApp, iMessage, and Browser

WhatsApp — The Primary Channel

WhatsApp became my main communication channel with the agent, mostly because it's always on my phone. The setup uses a headless WhatsApp Web session that OpenClaw manages through its messaging integration.

The critical first step: allowlisting. OpenClaw's config lets you specify exactly which contacts or groups the agent should respond to. This isn't optional—without it, the agent would respond to anyone who messages you. My allowlist is locked down to just my own number and a private "AI Tasks" group I created.

For group chats, you can require that the agent only responds when explicitly mentioned. This means I can add it to my team's dev group without it chiming in on every message—it only activates when someone says @agent.

I use WhatsApp primarily for on-the-go tasks. Walking to the subway? "Check if the staging deploy finished." Waiting for coffee? "What's the status of PR #247?" It turned my phone into a remote control for my dev environment.

iMessage via BlueBubbles — The Seamless Option

Since I'm on macOS, I set up iMessage through BlueBubbles. The integration feels native—messages from the agent show up just like any other iMessage conversation.

I use iMessage for more personal, low-friction interactions. Quick reminders, casual questions, things that don't feel like "work." There's something psychologically different about getting an iMessage versus a WhatsApp message. iMessage feels like a friend texting you; WhatsApp feels like a colleague.

"Remind me to buy coffee beans tomorrow morning" via iMessage just works. The agent sets up a cron job and texts me back at 8 AM the next day. Simple, but delightful.

Browser Control — The Power Move

This is where things get interesting. OpenClaw can manage a Chrome instance through CDP, giving it the ability to navigate websites, take screenshots, fill out forms, and extract information.

The setup involves launching a dedicated Chrome instance with remote debugging enabled. OpenClaw connects to it and can operate it like a human would—clicking, scrolling, typing, reading page content.

My first real test: "Find me the cheapest direct flight to Berlin next weekend." The agent opened a flight comparison site, entered the dates, waited for results to load, filtered for direct flights, and sent me a WhatsApp message with the top three options—including prices, airlines, and departure times. With screenshots.

I sat there staring at my phone thinking, "We really are living in the future."

The Heartbeat: When Your AI Checks In On You

This is the feature that genuinely changed my daily routine. OpenClaw has a concept called HEARTBEAT.md—a markdown file that defines what the agent should proactively monitor and communicate about.

Combined with cron scheduling, the heartbeat system lets your agent initiate conversations with you. Not just respond to your messages—start them.

My Morning Briefing

Every morning at 7:30 AM, my agent sends me a WhatsApp message with:

  • Today's weather and whether I need an umbrella
  • My calendar for the day (meetings, deadlines)
  • Unread GitHub notifications summary
  • Any CI/CD pipeline failures from overnight

Before I even open my laptop, I know exactly what my day looks like. It's like having a chief of staff.

Proactive Monitoring

Beyond the morning briefing, I've set up several monitoring crons:

  • PR staleness check (daily at noon): flags any pull requests that have been open for more than 3 days without review
  • Dependency audit (weekly on Mondays): checks for outdated or vulnerable dependencies across my projects
  • Standup draft (daily at 9 AM): drafts a standup update based on my git commits and closed PRs from the previous day

The "Weird" Feeling

I'll be honest—the first time my phone buzzed and it was my AI agent texting me about a failing pipeline, it felt strange. Like, genuinely unsettling for about three seconds. We're conditioned to think of AI as something we go to, not something that comes to us.

But after the initial weirdness wore off (took about two days), it started feeling natural. Now, when I don't get my morning briefing—like when my machine restarted overnight and the agent didn't start back up—I actually miss it. That's when I realized this had become a real part of my workflow.

Real Examples From My Week

The Gym Moment

Wednesday afternoon, I was at the gym between sets when I remembered I'd kicked off a production deploy before leaving. Instead of cutting my workout short to go check, I pulled out my phone and texted: "Did the production deploy to main succeed?"

Thirty seconds later: "Yes, deploy completed successfully at 2:47 PM. All health checks passing. Zero errors in the last 5 minutes of logs." Back to deadlifts.

The Browser Research

I was evaluating two API providers for a side project. Instead of spending an hour tabbing between pricing pages and feature matrices, I asked the agent: "Compare the pricing and features of Resend and Postmark for transactional email. I'll be sending about 50k emails per month."

Ten minutes later, I got a structured comparison with pricing breakdowns, feature differences, rate limits, and a recommendation. It had actually navigated to both sites, found the current pricing (not the cached version from its training data), and compiled it all into a clean summary.

The Heartbeat Surprise

Thursday morning, 7:32 AM. I'm making coffee. My phone buzzes:

"Good morning! Heads up: the CI pipeline for the develop branch has been failing since 11:47 PM last night. The failure is in the integration test suite—looks like a flaky database connection test. 3 commits are blocked. Want me to investigate further?"

I hadn't even opened my laptop yet. By the time I sat down at my desk, I already knew the issue and could jump straight to fixing it. No wasted time checking dashboards, reading through build logs, or figuring out what went wrong. The agent had already triaged it for me.

The iMessage Grocery Reminder

This one's small but it made me smile. Sunday evening, I texted via iMessage: "Remind me to buy coffee beans tomorrow." Monday at 8:05 AM: "Don't forget to buy coffee beans today!" That's it. No app to open, no reminder system to configure. Just a text message like a friend would send.

The Late-Night Idea

Friday at 11 PM, I was lying in bed when an idea for a new feature hit me. I didn't want to lose it, but I also didn't want to open my laptop. So I texted: "New feature idea for the blog: add a 'related posts' section at the bottom of each post, using tag similarity to find related content. Can you draft an implementation plan?"

When I woke up Saturday morning, sitting in my WhatsApp was a detailed plan: data model changes, the similarity algorithm, UI mockup description, estimated effort, and even a suggested file structure. My midnight brain dump had turned into an actionable plan overnight.

What Actually Changed in My Day-to-Day

Async-First Thinking

The biggest shift wasn't any single feature—it was how I started thinking about tasks. Instead of "I need to do this now," my default became "let me send this off and check back later." Fire and forget.

Need to research something? Text the agent and go do something else. Need a code review summary? Send the PR link and come back in 10 minutes. Need to check if something is deployed? Ask and move on.

Phone as Remote Control

My phone went from a distraction device to a genuine productivity tool. I can interact with my development environment from anywhere—the gym, a coffee shop, the subway. Not through some clunky SSH app or web dashboard, but through the same messaging app I use to text my friends.

The "Teammate" Feeling

There's a popular Slack post floating around about how AI coding assistants feel like having a junior developer on your team. OpenClaw takes that further—it feels like a personal assistant who also happens to be a developer. The proactive heartbeats are what sell this illusion. Teammates don't just answer questions; they bring things to your attention without being asked.

Less Context-Switching

Before OpenClaw, checking on a deploy meant: open laptop → open terminal → SSH/check dashboard → read logs → context-switch back to what I was doing. Now it's: text "is the deploy done?" → read the response. The cognitive load reduction is real.

The Honest Downsides

I promised an honest account, so here are the things that aren't great.

Token Costs Add Up

Heartbeats are a known token sink. Every proactive check involves the agent processing its HEARTBEAT.md instructions, executing commands, interpreting results, and composing a message. My morning briefing alone costs roughly $0.15-0.30 in API tokens depending on how much context it needs to pull.

With all my crons running, I'm spending about $3-5 per day on agent interactions. That's $90-150 per month. Not insignificant. You need to be intentional about what you automate and what actually deserves a heartbeat check.

Security Is Real

Let's not sugarcoat this: you are giving an AI agent access to your shell, your browser, and your messaging apps. If the agent gets a prompt injection through a malicious message, the blast radius is enormous.

Allowlisting isn't just a nice-to-have—it's mandatory. Without it, anyone who can message you on WhatsApp could potentially instruct your agent to execute commands on your machine. OpenClaw's default config isn't locked down enough out of the box, in my opinion. First thing you should do after installation is restrict who can talk to it.

The Meta Incident

It's worth mentioning the elephant in the room. Shortly after OpenClaw's initial release, a Meta AI researcher reportedly used it to automate outreach to other researchers in ways that weren't... well-received. The details are fuzzy, but the lesson is clear: an agent that can message people on your behalf can also message people in ways you didn't intend. Guardrails matter. Allowlists matter. Testing your cron jobs in a sandbox before letting them loose matters.

Not Everything Needs an Agent

I caught myself automating things that didn't need automation. Do I really need a heartbeat to tell me the weather? My phone already does that. Do I need the agent to check my calendar? I can glance at my watch.

The temptation to over-automate is real. After the initial excitement, I pruned about half my cron jobs. The ones that survived are the ones that genuinely save me time or catch things I'd otherwise miss (like the CI failure).

My Config

Here's a simplified version of my setup for anyone who wants to try this themselves.

openclaw.json (key parts)

{
  "llm": {
    "provider": "anthropic",
    "model": "claude-sonnet-4-6"
  },
  "messaging": {
    "whatsapp": {
      "enabled": true,
      "allowlist": ["+1XXXXXXXXXX"],
      "groups": {
        "respond_to_mentions_only": true
      }
    },
    "imessage": {
      "enabled": true,
      "provider": "bluebubbles",
      "allowlist": ["+1XXXXXXXXXX"]
    }
  },
  "tools": {
    "shell": { "enabled": true },
    "browser": {
      "enabled": true,
      "cdp_port": 9222
    },
    "filesystem": { "enabled": true }
  },
  "heartbeat": {
    "enabled": true,
    "file": "./HEARTBEAT.md"
  }
}

HEARTBEAT.md (simplified)

# Morning Briefing (7:30 AM daily)
- Check weather for my location
- Summarize today's calendar events
- List unread GitHub notifications
- Report any CI/CD failures from the last 12 hours
- Send summary via WhatsApp

# PR Staleness Check (12:00 PM daily)
- List open PRs across my repositories
- Flag any PRs open > 3 days without review
- Send alert via WhatsApp if any found

# Dependency Audit (9:00 AM Mondays)
- Run npm audit / bundle audit on active projects
- Report vulnerabilities and outdated packages
- Send summary via WhatsApp

Cron Setup

OpenClaw uses standard cron syntax in its config. Each heartbeat task gets its own schedule:

"cron": [
  { "schedule": "30 7 * * *", "task": "morning_briefing" },
  { "schedule": "0 12 * * *", "task": "pr_staleness" },
  { "schedule": "0 9 * * 1", "task": "dependency_audit" },
  { "schedule": "0 9 * * 1-5", "task": "standup_draft" }
]

Each task references a section in HEARTBEAT.md. The agent reads the instructions, executes the necessary commands, and sends results through the configured messaging channel.

Closing — It's Not About the Tech

After a week with OpenClaw, the thing that surprised me most wasn't any technical capability. It was a subtle shift in how I think about getting things done.

I used to think about tasks as "things I need to do." Now I think about them as "things that need to get done." The distinction matters. Some of those things genuinely require me—creative decisions, architecture choices, human conversations. But a lot of them? Checking if a deploy worked, looking up pricing, drafting a standup, remembering to buy coffee? Those just need to get done, and it doesn't matter if I do them or if an agent does them while I'm at the gym.

The heartbeat system is what makes this click. A traditional AI assistant is reactive—you go to it, you ask, it answers. OpenClaw is ambient. It's there when you need it, but it also gently taps you on the shoulder when something needs your attention. That changes the dynamic from "tool I use" to "teammate I work with."

Is it for everyone? No. The token costs are real. The security considerations are serious. The setup isn't trivial. And there's a real risk of over-automating things that are faster to just do yourself.

But if you're the kind of developer who's always wanted a personal AI assistant that meets you where you are—in your chat apps, on your phone, in your daily routine—OpenClaw is the closest thing I've found to that vision actually working.

My advice: start small. Set up one messaging channel, add one or two heartbeat tasks, and live with it for a week. You'll quickly figure out what's genuinely useful and what's just novelty. And when your agent texts you about a failing pipeline before your morning coffee is ready? That's when you'll get it.

Want to try OpenClaw yourself? Check out the GitHub repository to get started. Fair warning: budget for API tokens and lock down your allowlist before anything else.

Comments (0)