Skip to content

How Does an AI Assistant Keep Working After You Close the Chat?

You ask your assistant to check Thursday's schedule, then close the chat and head out. An alert arrives: an existing school notice shows early pickup at 1:00 PM, and calendars show a conflict. Discover how background jobs, context packets, and tool harnesses keep working after the screen turns off.

How It Thinks8 min readEP 01
One request, tools in the middle, a draft for a person. A visual metaphor, not a product trace.
In this article
Prefer to watch?Watch the film on YouTube ↗Opens youtube.com

Imagine you are a parent heading out to dinner. Before leaving, you open your assistant and type: “Check our schedule and let me know if everything is okay for Thursday.”

Your AI assistant confirms that the check has started. You close the chat window, put your phone away, and head out. While you are out, an alert arrives: Thursday's school pickup is earlier than usual, and the usual plan has a conflict.

You have not typed another message or kept the conversation open. How did the assistant keep working after you walked away?

To see how that happens, we have to look back at the moment you pressed send. This is an example of an assistant app designed to continue an already accepted and started task in the background. Not every chat app supports this design. In this system, however, closing the chat does not terminate the work you just set in motion.

Where the Work Continues

The chat screen on your phone is simply the place where you entered your instruction. The job itself is running on the service's remote computers. Closing the window does not cancel an accepted background job, just as closing a delivery app does not cancel an order once the restaurant receives it.

For a schedule check, the software stores a record of your request and its progress so the work can continue independently of your screen. A program on the service's servers picks up that record and carries the work forward. That is the background job: an accepted task continuing its execution somewhere other than your device.

When the system needs to interpret messy text or decide what to check next, it calls the AI model. This is where the distinction between the software and the model becomes clear:

  • The software manages the ongoing job, holds connections to external services, and tracks progress.
  • The model works only with the specific information the software gives it, producing an answer or requesting another step.

The part of the software that surrounds the model and manages this work is often called the harness. The harness supplies the model with the context and tools it needs, while keeping track of the overall task and what it is permitted to do.

The model does not need to think continuously while you are at dinner. Running reasoning loops across remote servers means the software does not rely on keeping your phone awake to do the heavy lifting. The software simply waits for an external search to finish, brings the result back to the model, and continues the work.

A phone shows a schedule check accepted before the chat closes; a saved task record and worker continue, then an enabled alert reports the finding.
An assistant built for background tasks can continue an already accepted check after its chat screen closes. This is one supported design, not a feature of every chat app.

Getting the Facts into the Conversation

To check Thursday, the assistant needs more than your brief prompt. In this example, you have already linked your family calendars and school messages, granting the software permission to read them.

The software starts by giving the model your request alongside descriptions of the connections it is allowed to use. To answer your question, the model requests Thursday's calendar entries through a tool.

A tool is an authorized way for the software to do something outside the conversation, such as searching messages or reading a calendar. The model cannot inspect records on its own; it specifies what it needs, and the software validates the request, executes the lookup across the permitted connection, and returns the result.

Your shared family calendar shows the usual pickup at 3:15 PM.

If the system stopped at a simple calendar check, it might conclude everything is fine. But your request was to check whether the day works, and a calendar does not always capture unexpected changes. That gives the model a reason to request another check: searching the school messages already available to the software. The software carries out that search across existing messages and returns the relevant notice.

Inside a school newsletter, it finds an update: Thursday is a shortened day, and students will be dismissed at 1:00 PM. The model checks which Thursday the notice refers to and confirms that it applies to your child's school.

Now there is a specific discrepancy to investigate: the family calendar still says 3:15 PM, but the school notice says 1:00 PM.

Why That Change Matters to You

Finding an earlier dismissal does not yet tell the assistant whether your family has a scheduling problem. It needs to know how pickup normally works.

In an earlier conversation, you told the software that Alex usually handles Thursdays, and the software saved that routine. For this task, it retrieves that relevant note and supplies it to the model alongside the newsletter and calendar results.

The model did not learn your family arrangements during its original training. Training gives a model general language skills and broad capabilities; it does not grant it access to your private routines. Those personal details are provided during the run, drawn from information you have shared or permitted the software to read.

Think of a storage folder and a desk. The folder holds records you may need later. For this specific job, you pull out only the relevant pages and lay them on the desk.

Here, the saved records are the folder; the material supplied to the model is its working context. The model still brings its general knowledge, but this working context is where it receives the private details needed for your task. Because there is a limit to how much material fits into one call, the software selects relevant information rather than sending your entire history.

With those facts gathered, the next check becomes clear. If Alex normally handles pickup, can Alex make the earlier time?

Saved routine pages are retrieved from a folder onto a working desk with the request, school notice and calendar results; private facts are supplied to a model call.
Persistence and working context do different jobs: the software keeps records, then selects relevant information for the model’s current call.

Following the Answer to the Next Question

The model requests Alex's relevant calendar entries through the access already shared with the software. The software verifies access, runs the query, and returns the result: Alex's calendar shows a meeting that overlaps the revised pickup time.

The model then asks to inspect your work calendar, and the software returns an overlapping appointment there as well.

Notice how each result changes the next question. Because the school notice changes the pickup time, the old calendar entry is no longer enough to judge the day. The saved routine tells the assistant whose schedule to inspect first; when Alex's calendar shows a conflict, your calendar becomes the next logical place to look.

For each new model call, the software includes the useful earlier information and the latest result. That keeps the process moving forward, even though you are not there to supply the next prompt.

This is where language understanding adds something beyond rigid data queries. The school could write “early dismissal,” “shortened day,” or “classes finish after lunch.” The model interprets that phrasing in context, connects it to your routine, and works out what needs checking.

However, a model can also misread a notice or miss a relevant message. That is why the answer needs to show its sources and flag what it could not verify. If an external calendar is unshared or a connection fails, that means availability is unknown, not that the person is confirmed busy. A calendar entry itself reflects a scheduled commitment, rather than an absolute physical certainty.

Looking for an alternative, the model requests a search of earlier notes and messages. The software returns an older message in which Grandma offered to help with pickup.

Its date matters: an old offer makes her someone to ask, not someone already booked. Without access to her current schedule, her availability is unknown. Even an empty calendar would not establish that she agrees to help.

A model call receives context and requests a calendar lookup; the software harness checks access, runs permitted tools and returns results for the next call.
The model requests; the software executes. Each result can change the next question. A calendar conflict is evidence of a scheduled overlap, not proof of unavoidable unavailability.

Bringing the Useful Answer Back

At this point, the assistant has enough information to deliver a useful answer:

“Thursday needs attention. The school newsletter says pickup is at one instead of three fifteen. Alex's meeting and your appointment overlap that time. Grandma previously offered to help, so she may be worth asking. I've prepared a message for you to review.”

The draft asks whether Grandma can help this Thursday. In this system design, that draft stays parked inside your private conversation.

Permission to read schedules and flag a problem does not automatically include permission to contact someone externally or commit them to a task. Reading records through an external connection is an authorized tool action, but reaching out into the real world to message someone involves a separate boundary. In this workflow, that action remains with you.

The software saves the answer with links to the supporting information and sends a notification through the channel you enabled. When you look at your phone over dinner, you can see both the problem and what to do next.

The check is complete, even though the pickup arrangement still requires your decision.

That is how an answer arrives after the chat closes. The software preserves and runs the job; the model interprets what comes back and helps choose the next step. Together, they carry your original question far enough to find an issue, explain why it matters, and leave you with a clear choice.

A private unsent pickup draft sits beside permissions allowing reading and drafting while contact and commitments remain blocked.
The schedule check can be complete while the pickup decision remains open. This example permits reading and private drafting; it does not authorize sending a message or committing someone to pickup.

Frequently Asked Questions

Does the AI model stay active on my phone after I close the chat?

No. In this architecture, the task runs on remote servers where the software manages the job. The AI model is invoked only when the software needs to interpret text or decide on the next step; it does not run continuously in the background.

How does the assistant know my personal routine if the model was not trained on it?

The model's original training provides language and reasoning skills, not your private life. Your routine is stored by the software as a private note. When the job runs, the software retrieves that specific note and provides it as immediate context for the model to review.

Why doesn't the assistant send the message to Grandma automatically?

Permissions are specific. Granting an app permission to read calendars and search messages to spot conflicts does not mean it has permission to contact people on your behalf. In this design, the draft is prepared for your review so that real-world commitments remain under your control.

Continue exploring all How It Thinks explainers, or learn about How It Thinks.

  • AI assistants
  • background jobs
  • harness
  • context
  • tool use
  • memory
  • permissions
Building an agent?We build agents and prove how they think.
Start a build