Agents & Assistants

Every agent comes with its own computer.

Every vendor in this industry sells an AI assistant, and almost all of them mean a chat box. An agent here is given a job, a seat and a machine to do the work on. That is the difference between software that advises your team and software that relieves it.

The agent

A teammate with a job, not a chat box

Each app gets its own agent. It has a role, the knowledge that role needs, the tools that role uses, the permissions that role should have, and a goal it is working toward. People on your team get one too.

  • One agent per app and per seat, not one bot for the whole company
  • Scoped by store, location and department like every other record
  • Works a goal you set rather than a workflow you have to draw
An agent with its role, its tools and the goal it is working

Its computer

A real machine, not an API key

Every agent is issued its own isolated computer. A browser it stays logged into, a place to write and run code, the ability to install a tool it turns out to need, and storage that persists between sessions. It is the difference between an assistant that can describe the work and one that can do it.

  • A browser with saved logins, so it is not signing in from scratch every time
  • Writes and runs its own code when the job needs more than a click
  • Installs the tools a task calls for instead of waiting on us to add them
  • Isolated per agent, so one store’s work never touches another’s
portal.example.com Agent
An agent’s own machine: the session it stays logged into and the tools it has installed

No API required

It can use the software that was never meant to be automated

Most of the systems a dealership runs have no integration worth the name. An agent with a computer does not need one. It works those tools in a browser the way your team does, on your own network, signed in with credentials you control.

  • DMS screens, vendor portals and OEM systems with no public API
  • Runs on your network with credentials you can revoke like an employee’s
  • Every session recorded end to end, so you can see exactly what it did
  • Answered
  • Waiting
  • Escalated
  • Answered
  • Scheduled
A recorded browser session working a vendor portal step by step

Watch it

A screen you can look at, and take

You can open an agent’s screen while it works. When it hits a login prompt, a two-factor code or a decision that is not its to make, you take the wheel, do the part only a person can, and hand it back.

  • Live view of what the agent is doing, while it is doing it
  • Take over mid-task and give it back without losing the thread
  • It remembers what you did, so the next run does not stop in the same place
portal.example.com You
Hand back
The same screen with a person holding the cursor, one click from handing it back

Memory

It gets better at your store, specifically

An agent keeps what it learns. Your pricing rules, your trade policy, your hours and your voice live in Knowledge, written in plain language by a manager rather than a developer. What it worked out last Tuesday is still there on Wednesday.

  • Knowledge edited by the people who know the answer
  • Long-lived memory across sessions, not a context window that resets
  • Corrections you make on an approval feed straight back in
Knowledge and memory behind an agent, with where each rule applies

Handoff

It knows when to get a person

Escalation is a first-class thing here, not a fallback for when the model gives up. You decide what an agent must never decide alone, and it hands over with the full context rather than a transcript.

  • Escalation rules per app and per location
  • Arrives in the Action Center with everything a person needs to decide
  • Advisory, approve or autopilot, set per job and reversible
Advisory
Approve
Approve
Approve
Autopilot
An escalation arriving in the Action Center with its context

What an agent ships with

The part nobody else gives it.

Any vendor can put a language model behind a text box. An agent is only as useful as what it can reach, so each one is issued the same kit on day one.

  • A browser

    Its own session with saved logins and profiles, so it picks up where it left off instead of starting cold.

  • A code runtime

    It writes and runs code when a job needs more than clicking, and keeps what it built.

  • Tools on demand

    It installs what a task turns out to need rather than waiting for us to ship support for it.

  • Long-lived memory

    What it learned last week is still there this week, per store and per role.

  • A screen you can watch

    Open it mid-task, take over for the part only a person can do, hand it back.

  • Its own isolation

    A machine per agent. One store’s credentials and work never sit beside another’s.

Questions

Worth asking.

What do you mean by "its own computer"?

Each agent runs on an isolated machine of its own, with a browser, a filesystem and somewhere to run code. It is not a shared sandbox and it is not a metaphor: the agent has a desktop in the same sense an employee does, and you can watch the screen.

Is an agent the same as an assistant?

Same thing, described from two directions. Assistant is what it is to the person it works with. Agent is what it is when it is working: given a goal, issued a machine, and accountable for an outcome.

Which model does it use?

The one that fits the job. We route between frontier models by task, and you are not locked to a single vendor as the field moves.

Can I see what it did?

Every action is logged with the input, the tool it used and the result, and browser sessions are recorded end to end. Nothing happens off the record.

What stops it doing something I did not want?

Permissions decide which tools an agent gets at all, autonomy level decides whether it acts or proposes, and both are set per job and per location. Everything starts in advisory until you move it.

Start here

See it on your store.

A short walkthrough on your own inventory, your own channels, your own numbers. No slide deck.