In a company, an AI agent is a language model wrapped in prompts, tools and business rules, so that it can choose the next step of a process: look up data, act in a system, answer or hand the work to a person. It is useful only inside a process the company has already made explicit, with limits on what it may read and change.
The model is one part. Around it sit the instructions that describe the job, the tools that reach the systems of the company and the rules of the business. On each turn the agent reads the request, decides whether it needs data or an action, calls a tool and continues until it can answer or must give the conversation to someone.
In a company, that loop needs bounds. The caller is authenticated and permissions are resolved first, and the agent fetches only the data its task needs. Model calls and tools have deadlines. Tool iterations are limited. Long work goes to a queue with a reference that someone can inspect, and writes are made safe to repeat. When a dependency fails, the outcome is already decided: a partial answer, a retry or a handoff to a person.
Where it shows up in real work
I work on contract on the agents of a higher-education group that serves a student population of 700,000+. They run on Google Cloud and handle admissions questions, enrollment, appointment scheduling, routing to the right human team and everyday student support. My work there includes the machinery that decides whether a change to the agent may ship: scripted cases, a calibrated judge and a gate in the pipeline.
A second lesson came from a small team. At first our agents needed a lot of supervision, specific instructions and context handed to them every time. That changed when we made our own process explicit: how we leave evidence, how a story connects to a change, how work is reviewed and what the real state of a project is. The agent no longer had to rebuild everything from scratch. Autonomy was a consequence of the structure around it.
What it is not
An agent is not the model alone. Change the prompts, the tools or the rules and its behavior moves, so the agent is the whole arrangement. It is also not autonomy handed over on the first day: in my experience, autonomy arrives after the process is clear.
When a company needs one
A company is ready for an agent when the work has a known procedure, when the state of that work can be read from its systems and when a mistake can be noticed before it costs something. The order I follow is the one that worked for us: strengthen the process first, gain autonomy second, and then keep the result as an architecture that can be maintained, observed and audited.
My contribution: Built the evaluation harness, calibrated LLM judging, isolated case state and environment-specific evaluation gates.
What this supports: The public account describes golden cases as code, a calibrated LLM judge and the evaluation harness around them, on a Google Cloud agent stack.
What it does not establish: The figure of 700,000+ students describes the population served by the system. It does not measure simultaneous users, requests per second or personal ownership of the whole platform. Client code and data remain private.
Source reviewed:
Common questions
How many users can an AI agent serve?
It depends on the workload, not on the count of registered users. Hundreds of thousands of registered users do not mean that many conversations at once. Size the system from active users, peak requests per second, simultaneous sessions, tool calls per turn and latency objectives, and budget the model quota and the database pool together.
How do you know an agent still works after a change?
By making evaluation a gate in the pipeline. Scripted cases with fixed state run against the change, deterministic checks cover what a comparison can decide, a calibrated judge model scores the rest, and a failed verdict stops the release. A probabilistic system becomes shippable when the things around it are deterministic.
Should a company start by giving an agent more autonomy?
No. In the work I describe, autonomy was a consequence of strengthening the system around the agent. Once the process, the rules and the evidence were explicit, the agent could tell where the project stood and which actions were valid.
What happens when an agent cannot complete a task?
That is decided in advance. The system returns a partial answer, offers a retry or hands the conversation to a person, and long-running work moves to a queue with a job reference whose progress can be inspected. Retries use backoff and a bounded budget.