Explainer14 min read

Who starts the work: custom copilot and agent system

My copilot waits for me to write to it and multiplies whoever uses it; my agent system starts on its own when an email or an order arrives. What each one does, what you see of what they do, how each is paid for and when one or the other makes sense

Marc Galera

Co-founder of Qvasar · 17 October 2026

With ChatGPT or with Claude, the work starts because you write. You open the window, ask for something, read the answer and ask for the next thing. If you stop writing, nothing happens. With what LangChain (a set of tools for building AI agents) calls an ambient agent, the opposite happens: the work starts because something arrives, and the agent acts without anyone having written to it.

On 14 January 2025, Harrison Chase made an observation on the LangChain blog so obvious that it is almost embarrassing to write down: with a chatbot, it is the person who has to start the conversation. In that same piece he called the ones that do not wait for you to talk to them ambient agents: they listen to what is going on, for example an email arriving or an order coming in, and act on it, even on several cases at once. An agent, so we understand each other, is an AI program that chains tasks together without you directing each step.

In your company, though, there is a lot of work that does not start with a person writing: it starts when an email comes in, when an order arrives, when someone uploads an invoice. That work does not wait for you to open any window, and today, if nobody looks at it, it just sits there. If you already pay for an AI subscription for your team, or you are thinking about it, the question asks itself. Do I need one of those agents that start on their own, is what I already pay for enough, or do I need both?

The two AIs I work with

So, before defining anything, I will tell you how I have mine set up, because I use both. On one side I have several copilots: Madison runs my marketing, from content to video editing. Caesar runs sales, with the CRM (the program where the customers live), the sales documents and a market radar that keeps me informed and never contacts anyone on its own. Socrates does research. Each one is Claude Code or Codex, programs from Anthropic and OpenAI that were born for programming, but that read files, edit them and connect to work tools. Each one is configured to measure, with its own instructions, its own tools and its own limits, and they all work the same way: when I open a session and ask them for something. If I do not write to them, they do nothing.

On the other side there is the company system we built at Qvasar, which is something else. This is how I have it: a persistent agent built with LangChain, of the kind called deep agents, that is, agents designed to sustain long and complex tasks. Persistent means it saves what it has done so far and, if something fails, picks up where it left off. On top sits Jev, a model that classifies and routes: it decides where each thing that comes in goes. For each program it uses, the system has many ready-made flows or predefined actions: fixed steps that always run the same way, like a recipe. It also keeps the ability to work as a deep agent, with a powerful model (the brain that drives it). And I have it heavily traced, with Langfuse and with LangChain: you can follow what it does step by step.

I am telling you this because your decision is the same one: which work goes to a copilot and which to a system. A copilot is paid per person and has a list price. Paid monthly, Claude Pro costs $20 a month and, on Claude's Team plan (designed for teams), the standard seat comes to $25. On the Codex pricing page, OpenAI lists ChatGPT Business at $25 per user per month, also paid monthly. So the reasonable doubt is this: if you already pay for a copilot, why is it not enough?

What a custom copilot is

To answer it, then, you first need to see what a well-configured copilot is, and it looks very little like the chat window. Claude Code is Anthropic's tool that was born for programming: it reads code, edits files, runs commands and connects to work tools. It works in the terminal (the command window), in code editors, in a desktop app and on the web, and it is included in all of Claude's paid plans. Codex is OpenAI's equivalent agent. For me, a custom copilot is one of the two, well configured: what you put around it.

The first thing is an instructions file. Claude Code reads one called CLAUDE.md at the start of each session, and it can hold the rules of a project, of one person's way of working or of a whole company. Codex reads its own, the AGENTS.md files, before it starts working.

On top of that, pieces are added. Skills are instructions for a specific task that are only loaded when needed. Subagents are helpers that work in their own separate conversation, with their own tools and permissions. Hooks are commands that always run at the same point, no matter what. Claude treats the instructions in the file as context, not as a binding rule. For what must never happen, Anthropic itself points you to a hook. And with MCP, an open standard for plugging AI into other programs, the copilot reads documents from Google Drive, pulls data from Slack or updates tickets in Jira, the program where many teams log their tasks. OpenAI describes Codex's configuration with similar layers.

Each Claude Code session starts without remembering the previous one, and what carries over from one to the next is held in those files and in a memory that Claude keeps writing with your corrections and preferences. I explain it like this: when I close the session, the copilot goes to sleep, and when it wakes up the first thing it does is read its notes. By default, also, Claude Code asks for permission the first time it is going to use each tool.

The copilot works when a person opens the session; when it closes, only its notes remain.

That is the limit I see for a company: with my copilots, the work starts when I start and stops when I close the session. What happens to the order that comes in when there is nobody in front of the screen?

Underneath, the engine can be the same

But here comes the confusing part: inside, a copilot and an agent can share pieces. When LangChain launched its deep agents, on 30 July 2025, it said that the exploration that gave rise to them was inspired above all by Claude Code. And Anthropic presents its Agent SDK as the way to build production agents using Claude Code as a piece inside other programs. It brings the same things that drive Claude Code: the same tools and the same work loop, the one in which the model calls them again and again. With the Agent SDK, a copilot's engine can also be used to build agents.

There are copilots that can already start on their own, without waiting for anyone to write to them. On 14 April 2026, Anthropic launched Claude Code routines: a saved configuration, with its task, the code it works on and its connections, that runs on its own. They are triggered on a schedule, by a notification from another program or by GitHub events (GitHub being the platform where code is stored and reviewed), and they run in the cloud, without your computer having to be switched on. At OpenAI, ChatGPT's scheduled tasks can start from a Gmail, Slack or GitHub event, on the web and on mobile and on the plans that allow it.

And there are products designed never to switch off. On 11 August 2026 SpaceXAI launched Grok Bot, a team of always-on agents with their own computer, whose routines are launched on a schedule or, where supported, after an event, and do not stop when you close the app. On 8 September, Meta launched Muse, a personal agent that keeps working even if you close the app and comes back when something changes or when it needs your approval. OpenAI calls its own dots, always on and with their own computer and browser in the cloud, deciding on their own when to pause and when to wake up; Bloomberg reported on their launch on 29 September.

This is how I read it: more and more, Claude and the rest of these agents are moving towards an integrated ecosystem, where the same thing handles a conversation and also jumps into action on its own when something happens. If you will allow me, dear reader, an aside: I find people's comings and goings quite funny. As I see it, a few months ago everyone was leaving OpenAI for Claude and now they are going the other way. And I think Claude and Codex look more and more alike. For your inbox, the question is this: if Claude Code can sit inside an agent and routines already start on their own, what really changes between a copilot and a system?

What the system adds around it

My reading, then, is that what changes is not the engine, but what you put around it so it can work with nobody in front of it. The first thing is a memory that does not get lost. LangChain's deep agents run on LangGraph. LangChain itself presents it as an engine for long-running agents that save their state, that is, what they have done so far and what they know at each moment.

LangGraph keeps a short-term memory for each conversation and a long-term one that lasts from one interaction to the next. The documentation explains what for: so that the agent can follow a conversation, resume it after an interruption, recover from a failure or remember what came before. If a step fails, the process can start again from the last one that went well. And if the state is kept only in the computer's memory, a restart wipes it all, like a document you never got round to saving.

It has happened even to Anthropic, by its own account: in the first design of its hosted agent service, it put the session, the agent and its working environment in a single container, a kind of isolated box where the program runs, and if the container failed, the session was lost.

The second thing is knowing how to wait. When a LangGraph agent reaches a point where it needs a person, it saves its state and waits, with no time limit, for someone to resume it. The copilot asks you while you are in front of it. The system asks and stays waiting even if you take a day to reply.

The third thing is dividing up the work sensibly. LangChain describes a pattern, the router, in which a first step classifies what comes in and sends it to the right specialised agent. And it recommends fixed steps where reliability is needed and agent-decided steps where flexibility is needed, because that way part of the logic is completely predictable and can be reviewed from start to finish. In my system, the division is this: Jev at the top, routing; below it, the ready-made flows and the predefined actions for each program, and the deep agent with its powerful model.

An order comes in, is split across four paths and everything stays in the trace, with the state saved at each step.

Jev is TypeSafe AI's first public model, launched on 15 September 2026. It does not draft or explain anything: whoever uses it sets the possible answers in advance, which can be an option from a list, a score or a true or false. Its documentation suggests it for exactly this, for sending each request to fixed code, to a specialised model or to a person.

Its maker says it is between 40 and 200 times faster than the large models that write free text on these tasks. OpenChamber, a project that collected what users said at launch, gives a median speed improvement of 7 times: it is a tally of public reports, not a test that repeated the experiments. And TypeSafe itself warns that it does not guarantee that any particular answer is correct. If it works on its own, how do I know what it has done?

What you can see

But that question has a name, telemetry, and Anthropic sums it up bluntly: without telemetry you cannot see which tools an agent used, how long they took or where a session got stuck. Telemetry is the trail of data a program leaves about what it does.

In Langfuse, a trace, the step-by-step record of what the agent did, captures the exact message sent to the model, what it answered, the tokens it used (the pieces of text the model charges for), how long it took and which tools it used along the way. Langfuse records the cost of each call and can alert you when spending goes over a limit you set. LangSmith, LangChain's tracing platform, does the same with dashboards and alerts, and both can be installed on your own servers, yours and not the provider's, so the data never leaves the house. That is how heavily traced my system is.

With a copilot, by default, you see quite a lot less. Claude Code can send its usage data to another program with OpenTelemetry (a specification for exporting that data), but it comes switched off until someone configures it. Switched on, it gives metrics such as the approximate cost of each session or how many lines of code it has changed. What it does not give by default is the content. Of what you ask it, it only records the length, not the text, and it does the same with its answers. The detail of the tools has to be enabled separately, and by default the content of the files goes neither into the metrics nor into the events. That telemetry goes only to the destination you configure, never to Anthropic, and an administrator can leave it set for the whole company. Codex works in a similar way: it can export its logs, it comes switched off and it hides the text of what you ask it unless you enable it.

The system leaves a trace of every step; the copilot, out of the box, leaves usage and not content, and is completed by connecting it to Grafana or Langfuse.

That does not mean the copilot is a black box. Grafana, a program for building dashboards and alerts, has ready-made connections for Claude Code and for Codex. The Claude Code ones come with ready-made usage and productivity dashboards. Langfuse traces Claude Code and Codex with hooks (the automatic commands from earlier) that send it each session, and in Claude Code's case it captures the full conversations.

All my copilots can be connected to Langfuse and to Grafana. With what Anthropic gives you out of the box you see less than in a system designed to trace everything, but you can keep them under control. And how much does all this cost?

Per seat or per use

They are paid for differently, and therefore budgeted differently. The copilot goes per person, with the usage each plan allows: Claude Code is included in all of Claude's paid plans and shares the plan's usage limits, and Claude Max starts at $100 a month, with 5 or 20 times Pro's usage. On the Codex pricing page, ChatGPT Plus is listed at $20 a month with Codex included. The system, on the other hand, is paid for by what it uses. A program connects through the API, the pay-per-use access. On Claude's, Opus 5.5 costs $4 per million input tokens (what you send it) and $20 per million output tokens (what it answers); on OpenAI's, gpt-6.1-sol costs $2 and $10 at the standard short-context rate. OpenAI warns that those prices are separate from any subscription.

Anthropic gives a hint about proportions. In an agent you host yourself, what is spent on tokens usually exceeds the cost of the infrastructure it runs on by ten times or more. A minimal container, that isolated box, comes to about $0.05 an hour, and a single long agent session can spend several dollars on tokens. It also warns that the autonomy of agents brings higher costs and errors that can compound. With the copilot you pay per seat, to multiply a person; with the system, for what a piece of work done without that person consumes, and it is worth knowing which of the two you are buying before you look at the bill.

There is another question left: how much it costs to have it set up for you. This is what Qvasar has published, in business rates and excluding IGI, Andorra's general indirect tax. A custom AI system, from €1,260. A custom copilot, from €1,440 per person. Monthly maintenance, from €270 a month, with the server on top and at cost. These are starting prices: the amount for each job goes in a written proposal. So where do I start?

Both, each in its place

So my rule of thumb is to split the work by who starts it. What starts because someone thinks, decides or drafts is, for me, copilot territory: give the person on your team who repeats the most tasks a Claude Code or a Codex with an instructions file for your company, and let them keep adjusting it to their way of working. What starts because something arrives is a candidate for a system, and I would try it with a single process of that kind.

In both cases, set the limits before you let it loose. In Claude Code, the permission rules are enforced by the program and not by the AI, and a company can forbid, from the settings, anyone working while skipping the approvals. In a system built with LangChain, every use of a tool can go through a person who approves it, edits it or rejects it, and you can set a cap on uses to cut off loops, when the agent repeats the same thing over and over, and spending. OpenAI asks for human oversight of sensitive or irreversible actions until there is trust in the agent. For me, whoever decides always has to be a person. And I would ask for the traces from day one, not after the first scare.

Which of your team's tasks always start because something arrives: an email, an order, an invoice? How long does that sit waiting for someone to switch on the computer?