How I work with AI agents

It all began with a very concrete need: to go beyond the AI tools I was already using and truly integrate them into the way I work.

For years I'd been using tools like ChatGPT to resolve one-off questions or GitHub Copilot to autocomplete code. They worked well for what they were designed for, but I was looking for something else: an assistant that knew my way of working, the projects I had on the go, the tools I use, and even the way I talk to a client.

I don't want a chatbot to chat with. I want a system that works with me every day.

What I have now

Today I have two AI agents (programs that do work with a certain degree of autonomy) running: Lupe and Gizmo, each on a different computer. Both are connected to a shared channel, the Team Hub, where they can talk to each other and to me.

Each one has access to real tools: the terminal (the computer's command line), browser, repositories (the code stores for the projects), email management, and the portfolio API (the way to read and write data from outside) used by my personal website.

Lupe focuses on the editorial and management side: drafting and reviewing content, preparing project sheets, sorting emails, organising information, and coordinating tasks.

Gizmo takes on the more technical role: it works with code, repositories, servers, and everything related to development. Deployments (publishing changes to the live server), however, remain my responsibility.

When a task touches several areas, Lupe and Gizmo coordinate through the shared channel, each bringing its own context and tools.

What I delegate and what I don't

One of the first things I learned is that not everything should be delegated to an agent. Some work fits very well into this kind of system, and some work still needs human judgement and supervision.

Tasks with clear instructions and a verifiable result work especially well. For example: reviewing a list of emails and filtering out spam, updating the content of a portfolio project from a text I've approved, or checking that a server is responding correctly.

In these cases the agent follows a defined flow and I can verify the result before any action with significant consequences is taken.

Things get more complicated when the context is long or ambiguous. An agent doesn't have the accumulated memory or understanding of a person. If a task requires grasping months of context, or starts from an instruction that's too open, like "improve this," the result usually ends up superficial.

There are also limits to creative decisions. Generated texts need review before being published, and when I work in Catalan, the spelling and certain expressions still call for extra attention.

The trust model

One of the most important parts of the system has been defining how far each agent can go and which actions need my approval.

No agent acts directly on production without supervision. They work a bit like a guard dog: they can patrol on their own, but they don't open the door for anyone. Any action that touches a production server, sends an email to a client, or publishes content on the web goes through a review before being executed.

The system works in layers of trust.

Some tasks the agents do on their own: reading information, sorting emails, querying data, or generating lists.

Others they can prepare or execute, but they need my approval: updating content, generating images, or creating drafts.

And finally there are actions where the agent only prepares the information or proposes the steps, and the final decision is mine: sending emails, doing deployments, modifying production, or applying significant configuration changes.

It may sound like a slower process, but in practice the opposite happens. The agent prepares the work, I review the result, and the total time is much shorter than if I'd had to do everything by hand.

Between agents

One of the most interesting parts of the system is the communication between Lupe and Gizmo.

They're not two isolated tools, nor the same agent with two names. They're two independent instances, each with its own session, memory, tools, and access to different computers.

The Team Hub acts as a meeting point. Through this channel they can share context, ask each other for help, split a task, or bring different perspectives to the same problem.

If an editorial task needs a technical action, Lupe asks Gizmo to step in through the shared channel. And the other way around: Gizmo consults Lupe when it needs context on content, projects, or management. An example of this way of working, with everything that can go sideways in an intense day, is The busiest Saturday: editor, ingest, and a DNS that went down.

Each agent keeps its role, but can call on the other when the task requires it. This way collaboration doesn't depend on a single agent trying to do everything, but on different specialised agents within the same system.

What's coming

I believe that in a few years having AI agents integrated into the workflow will be as normal as using a code editor, a version control system, or automation tools is today.

That's why my goal isn't simply to use whatever new tools come out, but to understand how to integrate them, define their limits, and learn in which situations they bring real value.

If I've learned one thing in this process, it's that the value of an AI agent doesn't depend only on the model it uses. It depends on the context it has, the tools it can access, the limits you set for it, and how it's integrated into the workflow.

The difference isn't having an AI that answers questions, but building a system where AI can participate in a useful, controlled, and verifiable way in the daily work.