Here is the build: a prompt, a model, a handful of tools, an agent. One line of intent. An afternoon of work. It answers questions in the demo and everyone in the room can see the potential.
Here is everything the build does not include, and everything the agent will need before a customer or an auditor meets it. We group it into six areas, because that is how the work actually gets assigned.
Build and release
Every save of the agent is a version: the prompt, the model, the tools, the knowledge sources. Without that, "what changed since it worked" is a guess. Versions need environments to move through. A draft is tried in Dev, tested in UAT against real scenarios, and only a promoted build reaches Prod. When a build misbehaves, it rolls back in one move, and the version that is live is never in doubt.
Runtime
The agent calls models, tools, APIs, retrieval and integrations, each with credentials that have to be scoped and rotated. A production runtime routes each task to the model that fits, uses your keys rather than a vendor's, and runs where your data is allowed to live: your cloud account, or your own data centre.
Reliability
Every run produces a trace: duration, errors, retries, model and tool calls, cost, and the exact version of every prompt, model, tool and knowledge source involved. Alerts fire on latency, failure rates and spend. Without this layer, the first sign of a problem is a complaint, and the second is an invoice.
Quality
A demo proves an agent can work once. Production needs proof that it works on the cases that matter, before release and after it. Two gates before deployment: a playground to find the best configuration with evidence, and a test simulation with thresholds on real scenarios. Three stages after it: operational signals on every session, drift detection that separates sustained change from noise, and live evaluation metrics that find the cause and recommend the fix.
The standard matters too. An agent that finishes cleanly and makes the wrong call has not succeeded. We count a case as verified autonomous only when it was in scope, the required action was confirmed in the target system, every critical check passed, no person stepped in, and nobody corrected it afterward.
Control
Which tools may the agent call? Which actions need a person? What text may enter and leave the model? How much may one flow spend before someone is warned, and before it stops? These questions have to be answered by policy that is set once and applied to every agent, not re-implemented inside each prompt. And every action has to be recorded with the policy version that allowed it, because that is the question an auditor asks.
Scale
The second agent is where operating problems appear. Two teams build the same skill twice. Nobody knows which agents exist, who owns them or what they are allowed to do. Agents need to hand work to each other across platforms. A registry, with an owner, a version and an interface on every agent, turns each one into an asset the next team can reuse.
Why this is the product
Most teams discover these six areas one incident at a time, and stitch together a tool for each. The stitching is the cost: five vendors, five permission models, five audit trails, and a lifecycle that breaks at every handoff.
We built Phinite so that build, deployment, observability, evaluation and governance run as one connected lifecycle. Studio builds the agent. Connect plugs it into tools, data and other agents. Runtime is where it lives, with Dev, UAT and Prod. Trace proves what it did. Improve turns outcomes and failures into the next better version. Gate decides, for every action, whether it goes ahead, waits for a person, or is blocked.
The prompt is still an afternoon. Everything else is what makes it safe to rely on.