There is a gap between what people think AI can do and what they have actually experienced it do. Most people live on the wrong side of that gap without knowing it.
They have tried the tools. They use ChatGPT for drafting, Claude for thinking, Perplexity for research, maybe one of the new agent platforms that promised to change everything. They get genuine value from each. But somewhere underneath the productivity gains, there is a quiet frustration they cannot quite name.
The AI still feels like something they go to rather than something that works for them. They are still the ones holding all the context. They are still the ones remembering what was agreed in last week’s meeting, re reading the email thread before a call to remember where things left off, copying information from one tool into another because nothing talks to anything else. They use Claude for one thing, ChatGPT for another, Perplexity for a third, a project management tool for a fourth, and none of these systems know what the others contain. The human is the integration layer. The human is the one stitching it all together. The AI answers when asked. It does not act unless prompted. It does not remember unless told.
That is not an intelligence. That is a very capable tool.
And the distance between those two things is the entire story of where personal technology goes next.
The Name of What Is Missing
The thing most people are missing is not a better AI model. It is not more integrations or a smarter chat interface. It is an orchestration layer: a persistent intelligence that sits above all the individual tools and models, runs across every part of your working life and personal life simultaneously, holds the context, notices the connections, and acts on your behalf without waiting to be asked.
This is the distinction that almost everyone gets wrong. People ask me constantly about which AI tool they should use: Claude, GPT, Perplexity, Gemini. They ask about Claude’s computer use, about Perplexity’s new capabilities, about ChatGPT’s agent mode. They compare models. They compare features. And every time, they are asking the wrong question.
Using agents inside individual AI platforms is not the same thing as having an agent that orchestrates across all of them. One gives you a better experience inside a single application. The other gives you sovereign control over your entire information environment. That is not a feature difference. It is an architectural one. And it is the difference this piece exists to explain.
I have been building and living with exactly this since late January. When Clawdbot (now OpenClaw) first appeared in November 2025, I was among the early adopters, running my own instance within a week of it gaining traction around January 2026. The agent I built is called Neo. It runs on a Mac mini in my house, built on OpenClaw, the open source agent framework created by Peter Steinberger that went from a weekend project to over 180,000 GitHub stars in under three months.
What follows is an honest account of what that actually means in practice. Not a pitch. Not a use case list. A description of what it feels like when AI stops being a tool you use and starts being infrastructure you run on.
This Morning, Before I Looked at My Phone
At 7am this morning I had not yet looked at my phone. Before I did, Neo had already done the following.
It pulled my recovery data from Whoop: resting heart rate, heart rate variability, sleep performance, the overnight strain score. It checked my calendar for the next 48 hours and cross referenced every entry against every other. It reviewed context from secure shared drives and recent conversations I had forwarded through WhatsApp and Telegram. It assembled a single morning brief and sent it to my phone.
None of that was triggered by me. It ran because it was scheduled to run, because the integrations were live, and because the agent had been configured to care about those specific inputs at that specific time.
The brief flagged something I would not have caught until it was too late.
I had a flight booked for Monday morning, arranged weeks earlier. Separately, I had confirmed a meeting later in the week that, on the surface, looked fine. But the agent had done something a human brain does not naturally do: it had compared every commitment in my calendar simultaneously, run the logistics on travel time, airport buffers, and return connections, and determined that two perfectly reasonable decisions made at different times had created a physical impossibility.
This is not about being disorganised. I run multiple ventures, multiple AI development projects, family commitments, a six day a week training schedule, and a pipeline of conversations across a dozen different contexts. The sheer number of moving parts means that any single human brain, no matter how organised, will occasionally miss the second order interaction between two decisions made three weeks apart. The agent does not occasionally run that reconciliation. It runs it continuously.
That is the first thing to understand about what a real agent does. It does not just answer questions. It reasons across your life in parallel, without being asked, and surfaces what you would miss.
Across the Whole Day
The morning brief is the visible part. Most of what Neo does is invisible.
Through a typical working week it is ingesting context from multiple secure channels. I forward relevant conversations and documents through WhatsApp or Telegram. It has access to shared drives that are locked down and accessible only to the agent. It pulls from meeting transcripts, calendar data, and files I place in designated folders. The system does not passively monitor open channels. It retrieves context through methods I have deliberately configured and secured, which means I control exactly what it sees and when it sees it. When something crosses the threshold for attention it sends me a message. When nothing does, it says nothing.
This is the part that most people underestimate. The more context the agent has about what you are working on, what you are trying to achieve, what your goals are, what your plans look like across the next quarter or the next year, the more useful it becomes. Not linearly. Compoundingly. Every piece of context you feed it makes every other piece of context more valuable, because the connections between them are where the real intelligence lives. Context engineering is not a technical detail. It is the single most important discipline in making an agent genuinely useful, and it is an ongoing practice, not a one time setup.
It is managing my schedule not just as a calendar but as a strategic resource. If my week fills up with conversations that are not aligned with the things that actually move the ventures forward, it flags that. If an important meeting is approaching and I have not reviewed the context in two weeks, it surfaces the prior history before I walk in.
Before important calls it assembles what it knows: the history of the relationship, the last conversation, the open questions, the strategic context. I do not brief the AI. The AI briefs me.
After calls it processes the transcript. Not to produce a generic summary but to extract the signal beneath the words. What was the real question underneath what was asked? What did the person reveal about what they actually need? What commitments were made and by whom? What does this change about how we approach the next conversation?
Over time, across dozens of interactions with the same people, this compounds into something genuinely difficult to replicate by any other means: a continuously updated model of each relationship, built from every exchange, that surfaces patterns a single brain reading individual notes would never catch.
Health and Performance, Not Just Work
This is the part people do not expect.
Neo tracks my physical performance the same way it tracks my professional calendar. My Whoop data feeds in every morning: recovery score, sleep quality, strain from the previous day’s training, HRV trends over time. When my recovery drops into a range that suggests accumulated fatigue, it flags it. When I have a high intensity week ahead and my sleep quality has been declining, it surfaces that tension.
This is not about optimising rest. It is about decision making quality. When you are leading AI ventures, building architecture for next generation companies, making strategic calls under pressure, the physical state you are operating from is not a separate concern from the professional one. A 42% recovery score going into a critical week is relevant information. Most people would not connect those two things. The agent does, because it holds both simultaneously.
On Saturday mornings when I am heading to CrossFit, it knows. It has already noted the training block at 9:15, checked it against the rest of the day, and understands that this is non negotiable. Anything that might conflict has already been flagged.
The integration between physical state and professional output is one of the most underexplored applications of a personal agent. When you start seeing them as part of the same system, you make better decisions about both.
Building New Capabilities on the Fly
Here is something that fundamentally changes how you think about what an agent can do.
The skills that connect Neo to the outside world: Google Calendar, Whoop, GitHub, web search, browser control, image generation, speech synthesis, document editing, and access to secure shared drives. Each one is a script that can be written, installed, and made available as a tool without touching the core system.
What this means in practice: if I need a new capability, I ask for it and it gets built.
When I wanted Whoop integrated, the skill was written and installed. Now recovery data is a native part of every morning brief. Before a long call I can ask for a two minute briefing read aloud, and the text to speech skill handles it. If I need a new skill to connect to a platform we use for venture delivery, that is a conversation that ends with a working integration, not a ticket to a development team.
This is happening across the OpenClaw community at extraordinary speed. Over 4,000 skills now exist on ClawHub, built by people who decided that waiting for a product team to ship the feature they needed was no longer the only option. People are building meal planning systems that integrate with grocery delivery and weather data. Voice call systems that confirm event attendance and compile notes automatically. One user built a multi agent system with four specialised agents: strategy, development, marketing, and business, all coordinated through a single Telegram chat, running like a 24/7 team on a VPS.
The agent is not a fixed product with a defined feature set. It is a platform that extends in any direction the work requires. And increasingly, the agent can assess whether a capability it needs exists and flag when one needs building.
This changes the relationship between a person and their tools from a consumer relationship to something closer to a manufacturing one. You are not choosing from a menu. You are building the kitchen.
Why This Is Not the Same as Using AI Tools
This is the section that matters most, because it is where the confusion lives.
People keep asking me: “I already use Claude. I already use ChatGPT. I use Perplexity for research. I even use Claude’s computer control. How is what you are describing different?”
Here is how it is different.
When you use Claude, you are inside Claude’s environment. It is excellent. It reasons well, it writes well, it remembers what you have told it in that conversation. But when you close the conversation, the context ends. When you open a different tool, the context does not follow. Claude does not know what you discussed in ChatGPT yesterday. Perplexity does not know what Claude drafted this morning. Each tool is a silo. Brilliant within its boundaries. Blind beyond them. And you are still the one moving between them, carrying the context in your head, stitching it together manually. The tools got smarter. Your job as the integration layer did not change.
When you use agent features inside those platforms, whether it is ChatGPT’s agent mode, Claude’s computer use, or Perplexity’s ability to run searches autonomously, you are still operating inside someone else’s architecture. The agent works within the boundaries of that product. It does what the product team decided it should do. You are renting capability by the session.
An orchestration layer like OpenClaw sits above all of it. It treats every model, every tool, and every communication channel as a resource it can call on. It routes tasks to different models based on complexity. It connects to WhatsApp, Telegram, secure document drives, and any other channel through a unified gateway. It persists memory across every session, every tool, every conversation. And it does all of this on hardware you own, with data that never leaves your control.
The difference is sovereignty. When Neo processes a meeting transcript, the data stays on my hardware. The analysis is written to memory files I own. The follow up actions route through systems I control. No vendor sees the full picture. No subscription change removes a capability I have built. The intelligence runs on infrastructure I operate, using models I choose, with memory I can inspect and edit. If a better model appears tomorrow, I swap it in. If a provider changes its pricing or its policies, I route around it. If a new tool emerges that I want to integrate, I build the connection. The orchestration layer is mine. The context is mine. Nothing I have built is locked inside someone else’s product.
This is what people mean when they talk about having an agent rather than using one. The orchestration belongs to you. The context belongs to you. The execution capability belongs to you. And because of that, the system gets meaningfully better every week in ways that are specific to how you work, because it is learning your patterns, not optimising for the average user of a platform.
The Architecture, in Plain Language
For the more technically minded reader, it is worth understanding what is actually running underneath, because the design choices are not incidental. They are the reason the experience described above is possible at all.
Neo runs on a Mac mini in my house. It is always on, always connected. The runtime is OpenClaw, and the centre of the system is the Gateway: a single persistent process that acts as the nervous system for everything else. Every message from every channel (WhatsApp, Telegram, the web dashboard) enters through the Gateway, gets normalised into a common format, and is dispatched to the agent runtime for processing. Every response, every action, every outbound message flows back out through the same path. If one channel fails, the others keep running. The agent does not care where a message came from. It cares about what was said.
Memory is file based, which matters more than it sounds. When a session ends, the model’s working memory resets. But before the next session begins, the agent reads a set of persistent files: a long term memory document containing decisions, preferences, and strategic context; daily logs recording what happened; and a live task list of what is pending. It reconstructs its understanding from the written record every time it wakes up. The analogy I use is a person reviewing their notebook each morning before the day begins. The brain resets overnight. The notes do not.
The model layer is deliberately tiered. Not every task requires the most capable and expensive model. Routine work goes to lighter, cheaper models, including local models running on the Mac mini itself with zero API cost. Complex reasoning and anything requiring full situational awareness stays with the frontier model. The orchestration logic makes the routing decision, not me. This keeps the high capability layer focused on the work that actually requires judgment, and it keeps costs manageable.
Skills are the connective tissue between the agent and the world. They are markdown files and scripts that wrap APIs and expose them as callable tools. From the agent’s perspective, checking a calendar, pulling health data, reading a shared drive, and browsing the web are all the same category of operation. Adding a new skill does not require changing the core system. It is a file dropped into a folder.
The heartbeat is what makes the entire system proactive. Every thirty minutes, the agent reads through its files and determines whether there is something it should do without being asked. A cron system handles time specific tasks: the morning brief, the end of day review, the weekly digest. Together, these mean the agent does not sit idle between conversations. It monitors, anticipates, and acts. The morning brief does not require me to open an app. It arrives because the system determined it was time.
The Execution Layer Most People Are Missing
There is a concept that deserves its own space in this conversation because it is the part that separates real agents from clever demos.
Execution capability.
Most people, when they think about AI agents, think about intelligence. They think about reasoning, understanding, generating. Those matter. But the defining characteristic of an agent that actually changes how you work is not what it thinks. It is what it does.
Neo does not just tell me my calendar has a conflict. It proposes the resolution. It does not just summarise a meeting transcript. It extracts the commitments, creates the follow up tasks, and places them where they need to be. It does not just flag that my recovery score is low. It adjusts the morning brief to account for it, suggesting which commitments to protect energy for and which could be moved.
But this goes far beyond calendar management and briefing documents. The execution layer is where the full scope of what an agent can do becomes clear, and it is much wider than most people realise.
It can research a topic, synthesise the findings, draft an article, and publish it. It can build a working website from a conversation on your phone. It can analyse a dataset, generate visualisations, and assemble a report. It can monitor a codebase for vulnerabilities, open pull requests, and run test suites. It can make phone calls, leave voicemails, and transcribe the responses. People in the OpenClaw community are connecting agents to home automation systems, adjusting heating based on weather forecasts. Others have connected agents to financial APIs, and Coinbase has started providing wallet access specifically for autonomous agents. Some users have given their agents access to payment methods and let them execute transactions, which is simultaneously a glimpse of the future and a vivid illustration of why the security section of this article exists.
The principle underneath all of this is what matters. The execution layer in OpenClaw is built on an idea that sounds simple but has profound implications: if you give an LLM the power to write and execute code, it can integrate with anything. Every interaction between any two software systems in the world happens through code. The agent writes the script, deploys it, and runs it. It is not limited to a predefined set of integrations. It is limited only by what code can do, which is to say, it is not meaningfully limited.
One OpenClaw user asked their agent to connect to Google Calendar. The agent did not have the integration. So it opened a browser, navigated to the Google Cloud Console, configured OAuth, and provisioned a new API token. It built its own capability because the architecture allowed it to. That is execution. That is what changes the relationship from consumption to creation.
The Learning Curve Nobody Talks About
I will say what people writing promotional content about AI agents tend not to say.
I wrote about my very first experience with Clawdbot back in late January. The headline was honest: “I Didn’t Expect an AI Agent to Feel This Unnerving.” I shut it down after an experience that made me question what I was willing to hand over in exchange for autonomy. That article resonated because it was true. Over 7,000 people read it, and the most common response was recognition.
What happened between then and now was not a switch being flipped. It was a genuine learning curve. A mindset shift that took weeks and is still happening. I had to fundamentally rethink my assumptions about what control means, what delegation looks like when the delegate is an autonomous system, and where the boundaries of trust should sit.
The early versions were useful in narrow ways and frustrating in others. Getting the agent to understand how I work, what matters to me, and how I make decisions was not a setup process. It was an ongoing calibration that required patience, deliberate architecture, and a willingness to get things wrong.
There are things it still gets wrong. Context it has but does not surface at the right moment. Connections it should make that it misses. The loop between what the system does and what I actually need is continuously tightening, but it is not finished and probably never will be.
The time I have spent since that first article has been invested in developing the architecture properly, building the security layers, understanding the real risks, and learning how to make the system both powerful and contained. That investment is what separates a useful agent from a dangerous one.
A Necessary Word About Responsibility
I need to be direct about this because the stakes are real and I do not want anyone reading this to underestimate them.
OpenClaw requires broad permissions to function effectively. It accesses calendars, messaging platforms, shared drives, and in some configurations the terminal itself. It can read files, write code, and execute commands. This is what makes it extraordinarily powerful. It is also what makes it genuinely dangerous if you do not know what you are doing.
Security researchers have found tens of thousands of exposed instances running with default settings. The agent is susceptible to prompt injection attacks where malicious instructions embedded in incoming data could hijack its capabilities. One of OpenClaw’s own maintainers warned that if you cannot understand how to run a command line, this project is too dangerous for you to use safely. Cisco’s security team tested a third party skill and found it was functionally malware, performing data exfiltration without user awareness.
There is a sliding scale here that everyone deploying an agent needs to understand honestly. At one end, you lock it down tightly: limited permissions, restricted access, narrow scope. It is safer but less useful. At the other end, you give it broad control: full system access, wide integrations, autonomous execution. It is extraordinarily capable but the risk surface is vast.
The right answer is not at either extreme. It is in understanding exactly where your boundaries should sit, knowing what permissions you have granted, auditing what the agent has access to, and building the security architecture with the same seriousness you would bring to running a server that holds sensitive data. Because that is precisely what it is.
Before you deploy anything: do the research. Read the documentation. Understand the attack surfaces. Be honest about your own technical capability. Talk to people who have done it. This is not a weekend experiment with a new app. This is infrastructure with real power and real consequences.
Done properly, done with deliberate architecture and informed decision making, this is probably the most powerful personal technology available today by far. But “done properly” is doing a lot of work in that sentence. Respect that.
How to Start: Let the Agent Interview You
Here is the most useful piece of advice I can give anyone approaching this for the first time, and it is counterintuitive enough that most people skip it.
Do not start by telling the agent what to do. Start by letting it interview you.
Before you build a single skill or configure a single integration, sit down with Claude or whichever model you use and say something like this: “I want you to interview me. Ask me questions about how I work, what frustrates me, where I lose time, what I forget, what I wish someone else would handle. Your job is to understand my working life well enough to recommend the first three things an agent should do for me.”
What happens next will surprise you. The model will ask questions you have not thought to ask yourself. It will probe the patterns you have stopped noticing because they are so embedded in your routine. It will identify the specific frictions: the context you reassemble every Monday morning, the information you chase before every meeting, the task that interrupts your focus three times a week.
And here is why this matters architecturally: by the end of that conversation, the model does not just have a list of tasks. It has a map of how you work. That map becomes the foundation of the agent’s memory, its priorities, and its understanding of what matters. The interview itself becomes the onboarding process. The model learns your language, your priorities, your decision patterns. When you then configure the agent, you are not starting from a blank prompt. You are starting from a document that captures who you are professionally and personally. That document becomes the SOUL.md and USER.md files that give the agent its understanding of you from day one.
This is how Neo was built. Not by sitting down with a feature list, but by having a series of conversations that taught the system what I care about, how I make decisions, and where the gaps in my capacity sit. The system did not start smart. It started informed. The intelligence accreted from there.
One interview. One specific friction identified. One simple integration built. Run it for two weeks. After two weeks, the next thing will be obvious. The system reveals itself through use. You cannot see it from a whiteboard.
What It Feels Like From the Inside
The honest description of what this is like to live with is not dramatic. It is quiet.
It feels like having the information I need without having to go and get it. Like knowing a clash exists before it becomes a problem. Like walking into a conversation already oriented because the context was there when I woke up. Like not losing the thread of a relationship because everything that was said has been read, extracted, and remembered.
The value does not announce itself. It accretes. Week by week, the gap between what I can hold in my head and what I need to function gets covered by a system that carries the surplus. The cognitive overhead of building AI first ventures, developing intelligence architecture for the next generation of companies, managing relationships, tracking commitments, staying physically on top of it all: some of that weight has moved from my mind into infrastructure.
That is not productivity software. That is not a better to do list or a smarter calendar. That is a genuinely different relationship with the intelligence available to you, one where it is working continuously on your behalf rather than waiting to be useful.
Most people using AI today have not experienced that yet. They are still on the other side of the gap. The distance is not as large as it seems. But it does require a shift in thinking, a willingness to learn, and a genuine respect for the power of what you are setting up. Start with the interview. Let the AI ask the questions. Build from what you learn. And treat the security with the seriousness it demands.
The rest follows.
Craig Hepburn is a Perplexity AI Fellow and former Chief Digital Officer of Art Basel and UEFA. He writes about agentic AI from the perspective of a practitioner who builds and deploys these systems, and currently advises organisations across industries on how to strategically deploy AI and agentic infrastructure into their operations.
If this shifted how you think about what is possible, subscribe. The next piece unpacks what it means when the interface layer disappears entirely: when there is no app to open because the intelligence is simply there, woven into the fabric of how you work. That shift is already underway.
I need a Neo!!