The Agent Thing Got Me

I may be developing AI psychosis. Not the clinical kind. I mean the stupid founder version where every annoying workflow starts looking like something an agent should be able to touch.

This is a very cursed place to end up, because I didn't start messing around with OpenClaw because I wanted a personal assistant. I started messing around with it because I wanted to understand how these systems were built. I cloned the repo, ran it, poked around, added some skills, broke a few things, fixed a few things, and treated it mostly like research. I wanted to know what the edges looked like. What was easy, what was clunky, where the permissions got weird, what actually worked once you stopped talking about agents in the abstract and had one sitting there doing things.

Then I caught myself being annoyed that Clawy couldn't access my email.

Not to send emails. I still absolutely do not want that. I am not letting some crab-looking tool fire off messages on my behalf because it got a bit too confident about a thread. But I did want it to search old stuff, work out filters, and help me archive the obvious junk I didn't want to deal with manually.

That was the "oh fuck" moment. I had gone from "giving an agent access to my email sounds insane" to "why the fuck can't this thing already help with my inbox?" without really noticing the shift had happened.

Clawy, for context, is my OpenClaw-based setup with my own skills and a few bits glued around it. I don't think of it as a friend, coworker, companion, second brain, or any of that. That framing makes me want to walk into the sea. It's a tool surface. A weird one, but still a tool surface.

App exposure, not app switching

The email thing annoyed me because email admin isn't hard. Searching, archiving, cleaning, organising, filtering. None of that requires deep thought. The annoying bit is that email admin makes me open email, and opening email is where the whole thing goes sideways.

I go in to archive some old threads and immediately see five things that are probably relevant. A customer note. A follow-up I forgot. Some procurement thread that might matter later. A newsletter with one useful idea buried in it. Then I start reading. Then I check context. Then I realise I should probably reply to something. Then two hours have gone and I'm doing a completely different job from the one I opened the app to do.

My email client is not TikTok. It isn't trying to make me doomscroll. It's doing something much more annoying than that. It's showing me the full surface of a real system where a lot of things genuinely matter.

That is worse than nonsense distraction. If I get distracted by nonsense I know I'm being an idiot. If I get distracted by a real email from a real person about a real thing, it feels responsible. Sometimes it is. A lot of the time I've just let the wrong surface decide what my brain should care about.

This gets especially stupid when you're building shit because everything looks relevant. Email, GitHub, Twitter, docs, CRM, tasks. It all contains things that probably deserve attention at some point. Just not always now. It is basically doomscrolling except all the posts are plausibly work.

The same thing happens with GitHub. I open it to grab one issue and suddenly I'm clearing notifications, checking stale PRs, reading comments, fiddling with labels, and doing triage instead of building the thing I opened it for. GitHub is doing its job. Email is doing its job. The task manager is doing its job. That's almost the problem. Each app gives me too much of itself for the tiny thing I usually went there to do.

That is where the agent thing started making sense to me. I don't think the useful bit is that it does magical work. Most of the time it doesn't. The useful bit is much more boring: I can ask for the slice I need without opening the whole app.

Search the emails. Pull the issue. Check the next task. Find the file. Tell me the thing. Don't show me every fucking detail in the room.

I used to think about this mostly as app switching. Opening five tools breaks focus, which is true but also kind of obvious. The worse thing is app exposure. Even one app can be enough if that app has the right kind of context in it. These tools were built to show context, and that is useful when I'm trying to understand the whole system, but it's a disaster when I only need one narrow action.

The agent becomes useful because it sits between me and the noisy surface. I can express intent in one place, get the bit I wanted, and stay closer to whatever I was already doing. It sounds boring written down, but it changes the feel of work quite a lot. The old way makes every small action a potential detour. The agent way gives me a fighting chance of not wandering off.

Less human middleware

At first that mostly meant retrieval. Find this thing. Search that. Remind me what happened. Pull the relevant context. That alone is useful because half of working across a bunch of systems is just reconstructing what the hell is going on.

Then it starts becoming more than retrieval, because the useful workflows are never cleanly inside one app. An email can imply a task. A GitHub issue can turn into something I need to deal with today. A task may already exist, and adding another one makes the system worse. A random thought I dictate while working should land somewhere sensible without me opening the correct app, deciding the correct board, writing the correct title, and falling into admin cosplay.

This is why I ended up using Fizzy the way I do. I don't really think of it as my todo app in this setup. It's more like context plumbing. GitHub still holds code work because GitHub is better at that. Issues, PRs, branches, diffs, comments, CI, all of that belongs there. Fizzy is where work goes to bother me.

That distinction matters. I don't want my task system pretending to be the source of truth for code. I also don't want to open GitHub constantly just to find out whether something has become my problem. So GitHub holds the code work and Fizzy gets used as the place where the agent can surface what needs attention.

If an issue gets assigned to me, I don't want to discover that by opening GitHub and falling into triage. I want it to show up where I'm already looking for work. The same thing works the other way round. I can dump five random things into Clawy and it can add the missing tasks, ignore duplicates, or put things where they actually belong.

That sounds small until you notice how much of the day is just moving context around like an idiot. A thing appears in email, becomes a note, becomes a task, becomes a GitHub issue, becomes a follow-up, becomes a reminder, becomes another email. Somewhere in that chain I lose the thread, or I spend too long preserving the thread, which is somehow even more annoying.

The CSV example is the cleaner version of this. Find the file in my email, process it locally, run Python, make the graphs, package the output, and put it somewhere useful. That crosses email, local files, scripts, charts, and whatever review surface I need at the end. It's exactly the sort of thing that should be easy and somehow eats half a day because I become the person manually carrying state between every app.

I still need to review the result. I still need to know if the numbers make sense. I still need to make the call. But I don't need to be the clipboard between five different tools. That is the bit that has started to stick for me. Less human middleware.

Receipts turn "trust me" into "check this"

Now don't get me wrong, I am one paranoid motherfucker. I do not trust the agent with a ton of stuff.

Even trusting it to read my email felt weird, despite having it set up in a way I'm reasonably comfortable with and not running it through some sketchy LLM provider garbage. The annoying part is that the agent can probably do more than I'm comfortable letting it do. That is a strange new kind of product problem. The app can do the thing. The model can probably manage the thing. I still don't want it doing the thing.

I'm fine with reading, searching, filtering, drafting, and preparing. I still absolutely will not let it send emails as me. Same with spending money, posting publicly, merging code, deleting things, or doing anything destructive. Some of that I may never want fully automated. Some of it can be prepared but not executed. Some of it can happen only with review, receipts, and a rollback path that isn't complete fantasy.

You probably remember your December with Opus, or whatever your version of that was. The first time you let an agent loose on a real codebase, the scary part was not whether it could write code. It clearly could. The scary part was whether you trusted the loop around it: branch, diff, tests, PR, review, rollback.

Code already had receipts. That made coding agents easier to accept. A branch is visible. A diff is inspectable. Tests either pass or they don't. A PR can be reviewed. A bad change can usually be reverted. The whole system is already built around the assumption that people will fuck things up and you need a way to catch it.

The rest of my life does not work like that.

Email is the obvious one. The practical difference between drafting an email and sending an email might be tiny. Psychologically they are miles apart. A weird email is socially live once it leaves. You can't treat it like a bad diff. You can apologise, clarify, or look like an idiot, but the thing already happened.

So the permission boundary has to follow human comfort, not just technical capability. If it archives email, show me what got archived. If it creates tasks, leave cards and comments. If it touches GitHub, give me the issue, the PR, the diff, and the test output. If it runs some heartbeat in the background, tell me what changed and why I'm being interrupted.

Receipts matter because they turn "trust me" into "check this."

This feels a bit like the old "I'm not putting my credit card on the internet" thing. Online payments became technically fine before everyone became comfortable typing card details into websites. The capability was ahead of the comfort. Agents have some of that same energy. A lot of the design work is going to be around what people are actually comfortable delegating, not what the model can technically do.

Chat is for intent, not for review

There's another trap here, which is assuming that one interaction surface means everything should become chat. I really do not want everything to become a chat window. Chat is a good command surface because it's loose, fast, and already lives where I message people. It's a good place to say what I want. It is often a terrible place to inspect the result.

If I'm reviewing 500 CRM records, I don't want to interrogate a chat window like a detective. I want a table, filters, charts, and probably some ugly export button because that is how the world actually works. If I'm looking at code, I want a branch, a diff, tests, and a PR. If I'm working through a CSV, I may want a file, chart, PDF, dashboard, or some interactive view.

I played with this a bit in NIVEN, my wealth-management experiment. It was still chat, but the useful part was not the chat box. The useful part was letting the agent return richer outputs, like charts and interactive views, so the result could be reviewed in a way that fit the job. Text is good for intent. Output should go wherever review is least painful.

That is also why Clawy has stuck for me in a way normal voice notes never did. It sits in the corner of my second monitor inside the same messaging app I use for everything else. If a random thought hits while I'm working, I can switch over, hold the Wispr key, say the thing, send it, and go straight back to what I was doing.

That is very different from opening a task app, deciding where the task goes, writing the title properly, adding notes, setting a date, checking if it already exists, noticing three other tasks, cleaning one up, and then wondering what the hell I was doing before.

Voice notes could technically capture the thought. The problem is that I would never go through the pile of voice notes. They just rot. With the agent, the thought can become a task, a search, a draft, a reminder, or at least land somewhere less stupid than a random audio file I will never play back.

Before this, I basically had two bad options. I could break focus to handle the thought, or I could keep working and hope I remembered it later. One leaked attention immediately. The other leaked the thought later. Clawy gives me a third option: dump the intent and keep moving.

Why it got me

That's probably the whole reason this has got under my skin. My attention leaks at the edges of work. Not because I don't know what I'm doing, but because every tool contains more real work than the thing I opened it for. The agent helps because it reduces how often I have to enter those surfaces.

For the kinds of work where my attention usually leaks everywhere, this can feel closer to doing twice as much. That is not a benchmark. It's not even close. It feels like that because I'm staying inside the work for longer. Less context reload. Less "oh while I'm here." Less pretending I'll come back to the voice note. Less manually carrying state between tools.

That is why the agent thing got me. I still don't trust it with a ton of stuff. I still don't want it sending emails, spending money, posting for me, merging things, deleting things, or pretending to be a person. But I do want one surface where I can dump the stupid little bits of intent that used to either drag me into another app or disappear entirely.

I want agents around my judgment, not instead of it.

Mostly I want them to stop leaking my attention into every app I have to touch.