Living on the agentic frontier

There are two settled opinions about personal AI agents, and they can't both be right.

One says we're a release or two away from a digital chief of staff that runs your life while you get on with the important things. The other says it's autocomplete with better marketing. I've spent months running agents over my own data (my real calendar, my real health figures, my actual messages) in a system I call RafeOS, and I've ended up somewhere that fits neither camp.

Both sides are arguing about a place most people haven't actually been yet. I've been living there for months, further in than most, so this is the dispatch: what's been good, what surprised me, what quietly didn't work, and what it means for the way work gets done.

Am I using agents?

It's the first thing people ask, and I used to fumble the answer, because "agent" has come to mean many different things. I think the cleaner way to articulate it is as a spectrum.

At the simplest end, a plain passthrough (just showing data, with no model at all), then simple automations (deterministic rules, still no model), in the middle automatic workflows (a model doing one or more fixed steps in a path I've laid out), and, at the far end, genuine autonomous agents (a model handed a goal that works out the steps and the tools for itself, looping until it's done).

The first two sometimes get counted as agents, but it's the latter two, where there is model-backed reasoning, that I would count as AI agents. This still clearly encompasses a wide variety of complexity and sophistication, so the level of delegation and autonomy is still important to understand.

So, yes, by this definition, I'm using lots of agents. There are multiple workflows built into various parts of RafeOS, with varying levels of complexity (e.g. message triage, reading ranking, briefings). I have more of these workflows that I can call on-demand to do certain tasks (a lot of these are encapsulated as skills) and more that run as unattended scheduled tasks, some with quite complex goals.

My custom Claude Cowork setup behaves like an agent in itself and runs multiple sub-agents (including being home to some of the workflows mentioned above). The general RafeOS-enabled assistant I reach from within Claude and ChatGPT, or my messaging apps on my phone, is another. The coding harnesses that I use to build personal projects like RafeOS are agents. And then lots of the software I use also have agents in them, though my focus here is on the custom stack.

What I don't really have is the thing people usually picture: a fleet of named bots with personalities, a little family of agents. I treated that absence as a gap for a while, then stopped, because it's the cosmetic version of the question.

The skill isn't running the most agents. It's matching the level of autonomy to the task: a rule where a rule will do, a workflow where the path is known, a full agent only where the work is genuinely open-ended. An agent is the most capable and the least predictable option, and a lot of what a personal system does all day doesn't need one.

What's been good for me

The biggest win for me is that an agentic harness that's fully wired into my own context (and tools) is dramatically better than the out-of-the-box version of the same model. Working in Claude Code, Codex, or Claude Cowork, where the assistant is inside my substrate (a unified personal knowledge/data layer with project maps, curated context about my work and my life, session logs, plus access to local files) is something that still feels magical to me.

And it compounds. Every well-curated piece of knowledge, every project map, every tool you connect, and every pointer you write down is a thing you generally don't have to explain again, so the system gets quietly more useful the longer you live in it. Not because the model improved (though that's happening too), but because the ground it's standing on got richer. It's a slope, and it only tilts one way.

Anthropic and OpenAI know this well, which is why the project, tool and memory features bundled into their desktop and mobile apps have become increasingly impressive over the last 12 months. As an aside, this also means the lines between agentic interfaces have become increasingly blurred, though personally I still find it helpful to split things into agentic chat (ChatGPT, Claude Chat, Gemini, which act as conversational windows) and agentic harness wrapper (Codex, Claude Cowork/Code, Gemini Spark/CLI, OpenClaw, which wrap the model in a persistent local environment and give it direct tool-execution privileges).

Build less interface, not more

There's a pattern that runs through the whole system, and it's the opposite of what I assumed this would feel like. The goal turns out to be less interface, not more.

With hindsight this is obvious when building on top of a conversational interface (and is part of a bigger trend that is seeing more and more apps collapse into AI apps like Claude and ChatGPT), but it's a principle that goes further.

The morning briefing is where that pays off most visibly. Every input is mundane on its own; I could get the weather, the calendar and the train status myself in three apps and ninety seconds. The point is that I don't, and that the briefing has weighed them against each other before it reaches me.

The same shape governs the rest of RafeOS. Messaging doesn't show me every message; it floats the handful of important ones or the ones I've forgotten to reply to. Transport doesn't ask me to check it; it pushes a Tube delay to the top only when there's a disruption and it knows I'm about to head out, so the alert is prominent precisely when it's relevant. Somewhat embarrassingly, I spent some early time building perfectly nice transport and weather modules; I rarely open either (though both still feel super useful when I do need them because they are micro-personalised to me). Not because they're bad, but because the briefing made them redundant for the common case. The win is a quieter system, not a busier one.

The interface assembles itself around the moment, rather than waiting for me to come and find it — and because it’s built on my own context, what it surfaces is mine, not a generic feed. Less an app to navigate, more a system that’s already done the looking. This is what an adaptive user experience really means: a surface that reshapes itself around the person and the moment, instead of showing everyone the same fixed thing. I doubt this is where it stops.

Sparks across domains

One evening I was using Claude to think through the week ahead (planning agent), which included a visit to my parents, and it suggested I make time to relax with the kitten. A strange thing for a planning conversation to say.

Why it could is the interesting part: days earlier, in a completely separate context, I'd been using Claude to explore what you need for a new kitten, and that research was sitting in my shared substrate (I may have also later mentioned that Merlin had arrived, I honestly don't remember). In a different frame of mind entirely, it reached from the one domain into the other and made a sensible, human suggestion. It was kind of magic at the time (...after the fact probably predictable as it was likely reading context about my parents and also linking back to me saying it had been a stressful week).

These cross-domain sparks are the most striking thing I've seen and they keep happening (some joyful like Merlin, some genuinely thought provoking, others obvious-in-hindsight; and yes, some just wrong). It's surprised me because I keep my projects and domains fairly disciplined in my second-brain setup, but the moments of delight appeal to my systems-thinking heart, so I have started seeking them out more deliberately.

Sparks across tools

The kitten was the substrate reaching across two domains in memory. The same thing happens a layer down, in the tools — except there it isn’t memory doing the reaching, it’s an agent composing capabilities I never wired together by hand. The morning I got into SXSW London sessions I’d otherwise have missed is a good example.

I’d had an agent research the sessions — which talks, when, where — and at the end it offered to set up a scheduled task to re-check, because these events shuffle the schedule on the day. I said yes without thinking. What I hadn’t done was wire up any notification. But when the re-check ran, it reached for the RafeOS notify tools on its own and sent me a Telegram summary the next morning of what had changed, schedule-aware. I read it over breakfast, saw two sessions had shifted, and caught ones I’d have walked straight past.

Three things composed there (research, scheduling, and notification across a messaging channel) and I'd explicitly arranged none of that combination. Each capability already existed; the agent reached across them because they were all reachable from one place. The value isn't in any of the three tools, it's that they sit over one substrate and an agent can join them up without me drawing the lines first.

Memory reaching across domains, tools composing across a task: the same coherence showing up at two different layers.

The bit nobody demos

This stuff is jagged. It's brilliant in places and wrong in others, and the line between the two is not always where you'd predict.

An example I have: the weekly health briefing once told me, with total confidence, to "seek advice on your blood pressure at the ENT appointment." It had taken an unusually high blood-pressure reading and a grommet-related ear-nose-and-throat appointment that happened to fall around the same time, and stitched them into a single instruction. Two related, but separate health issues. There was no hedging in the tone. Just a clean, confident, and ultimately useless instruction.

That's the failure mode that matters, and it isn't "the AI doesn't know things." It's that the AI is generally designed to be exactly as fluent when it's right as when it's nonsense. The confidence is constant; the correctness isn't. The fix wasn't more intelligence, rather it was updated instructions (a lesson against conflating a health finding with an unrelated appointment).

The other half of the jaggedness is me, not the model. I've done some of these tasks by hand for years, and handing them over is a behaviour and mindset change before it's a technology one. Behaviour change runs on trust, and trust is earned slowly. The system has to be coherent often enough that I stop double-checking it, and that coherence over months, not any single clever output, is what is shifting how I work. I trust the briefing now the way you trust a new colleague (which, if I'm really honest, is not 100%... so still in the trust, but verify stage).

You only find out what sticks by living with it, and "what sticks" is a far better measure of value than "what demos well." A lot of what demos well doesn't survive a normal Tuesday.

Where RafeOS sits, and why it's early

Taken one at a time, my modules are commodity — a task list is a task list, a messaging bridge is a messaging bridge, and, even with some extra AI smarts, none of those pieces would impress anyone who's built one.

What's rare isn't the parts. It's assembling them into one coherent thing you actually live inside — everything over a single store, reachable from a dozen surfaces. This is what makes the joins I described earlier (the kitten, the SXSW notification, the briefing) possible. Coherence is the hard part, the valuable part, and the part you can't buy as a component.

This is the exact wall enterprise AI is hitting right now. Most companies are buying isolated AI point-solutions from an AI writing assistant here to a customer service bot there. But the real enterprise frontier isn’t buying more tools; it’s building a unified context substrate. Until a company's data, across Slack, Salesforce, and internal wikis, is reachable from a single layer, their agents will remain blind. The winner won't be the company with the smartest model, but the one with the most coherent internal graph.

RafeOS is interesting mostly because it's early. Plenty of capable people are converging on this shape, and the platforms are racing to make it easy — but relatively few have actually built it and lived in it yet. I'm reporting from a little further in than most have gone, before the map is drawn.

And there are things other people's versions do that mine doesn't. I'm a geek at heart, so seeing what others have done, standing on their shoulders, and iterating is part of the fun. Or put another way, it's learning about the future by trying to live five minutes in the future.

What I think happens next

The near-term thing I'm watching most closely is local models. RafeOS has deliberately been built so the model underneath can be swapped out, and for my set up a local LLM is the next real test of that. So far it's been no more than an experiment, but the architecture was designed to allow it. Why it matters is partly economic and partly about timing. There's roughly a nine-to-twelve-month lag between what the frontier models can do and what you can run locally (leaving hardware constraints to one side), and that gap, combined with the token economics, is closing the case for personal use.

My best guess is that local LLMs in personal set-ups like this become more common in the back half of 2026 and into 2027. It’s already happening in enterprise, where the logic is identical, just magnified. For a corporate CEO, the calculation isn't about novelty; it's about margin and sovereignty. Moving to open, local, or hybrid infrastructure is the only way a business can aggressively run millions of agentic loops across proprietary corporate data without leaking intellectual property or getting crushed by API token costs. Or maybe this is just an excuse for me to stick another machine in the infrastructure cupboard!

The surface follows the job

The other signal is about interfaces — or rather, that there’s no single right one. Different jobs want different surfaces: a dashboard for the glance (“is everything roughly fine?”), messaging for running things on the go, an agentic harness for the dive (“help me think this through”) and the execution (“run this on auto”). And increasingly a fourth kind that’s barely an interface at all — scheduled tasks, embedded workflows and loops running in the background, surfacing only when they’ve something to say or a question to answer. The trend isn’t a single interface; it’s the surface following the job.

Flatter networks and evolved craft

This isn’t just a shift in interface design; it is a preview of an architectural pivot that challenges how we structure companies. The steadier, consistent win of this entire experiment isn't a specific automation, but the fact that the system-wide integration of context quietly absorbs the coordination tax; the checking, the cross-referencing, the keeping of plates spinning.

If this generalises, and the economics of the frontier suggest it should, the shift at work won't be about AI stealing jobs. It will be about redesign of craft workflows and the overhead of internal coordination compressing drastically. When ambient, cross-domain context becomes reachable from any point in an organisation, the structural justification for rigid tiers and roles reduces.

In an enterprise setting, this fundamentally redefines what we value in talent and how we structure organisations.

For team members, it doesn't imply we no longer need expert engineers, designers, or domain specialists; rather, their core craft must evolve. The premium shifts toward professionals who marry deep execution discipline with the ability to integrate and orchestrate agentic workflows. Their hard-won expertise becomes the ultimate quality filter; the structural backbone ensuring the system isn't just fast, but contextually and architecturally right.

For leadership, this forces a new kind of collaboration. Traditional, rigid hierarchies, which are essentially just manual networks built to route information up and down a chain, will struggle to keep pace. When status-chasing is absorbed by agents, a leader’s job moves from managing tasks to architecting the environment. It becomes a flatter, more fluid and integrative style of leadership: ensuring the team's underlying substrate and system is clean, encouraging a culture of psychological safety and inter-connectedness, while also guiding people through the messy behavioural transition of learning when to trust the automation and when to pull back.

Ultimately, stripping away the organisational and craft friction doesn't diminish the human role, it elevates it. It clears the field so we can focus on the work that always required genuine human judgment: the complex orchestration, the deep relationships, and the high-stakes decisions. Not a threat and not a utopia.

The baseline of the frontier

The agentic frontier is not a chief of staff and it's not a parlour trick. The occasional cross-domain spark and cross-tool synchronisation is real and helpful; the steadier, consistent win is that a system this wired into your own context compounds, getting more useful the longer you feed it. You learn to trust it at the speed trust is earned, you fence off the places it goes confidently wrong, and you need less interface rather than more.

That's less exciting than the pitch and a great deal more useful than the dismissal. Most of this will be ordinary in a year or two, which is exactly why it was worth living here first. After months of it, I'd take useful.

On how this was made: RafeOS is built collaboratively with AI, and this post was written by me, with some editing support from Claude. The nature of this post means it has a higher human proportion.