Build it, run it, ship it. In one place.
There’s a tool for authoring, another for evals, another for tracing, another for the deploy. Picking them takes a quarter, wiring them together takes the next one, and then two of them change. Here it’s one thing, in your own infrastructure, and the version you just ran is the version that ships.
Authoring that knows the schema.
Completion and validation as you write, so a malformed tool binding or an unknown model is caught in the editor, while the file is still open in front of you.
Run it against the real thing.
Fire a real payload at it, or talk to it, while you change it: its actual tools, its actual policies.
Out to a cluster from the same screen.
The version you just ran is the artefactartifact that ships. What you signed off is what staging and production both get.
An agent doesn’t have to be a conversation.
Records in, decisions out, on a schedule or when something happens. An agent here can be a plain API another system calls, or it can run unattended on a timer that remembers where it got to. Set it going on Friday and the Monday run carries on from where it stopped, instead of starting the year again.
Inside it, the steps that should be deterministic stay deterministic. The model sits in the one step that needs judgementjudgment.
The phone gets its own agent. Not its own stack.
It’s defined the same way as everything else here, with the same tools and the same policies. Speech in and out is a pipeline you configure: transcribe, think and speak as three steps, or a realtime model doing all three at once. Swapping between them changes nothing else about the agent, which matters while that end of the market is still moving.
Real conversations interrupt. Someone talks over it, changes their mind mid-sentence, goes quiet, and it copes. The hostile callers that prove it are the ones already in your test suite.
Speech, documents and images arrive as part of the work, and what may arrive at all is an attachment policy you set.
Speech and generated media come back the same way, stored where you told it to store them.
A tool call made because of something someone said out loud is still a tool call: same rule, same record, same redaction.
However the work arrives, it’s built the same way.
Which shape a piece of work takes stops being an architectural decision and becomes a line in the artefactartifact. The team that starts with a nightly job and the team that starts with a phone line learn one platform.
Anything you build can be exposed to another team’s agent as a tool, or called over MCP by whatever they already use.
Packs, skills and test projects sync from git, OCI or a config map, so the console is a place to work in and git stays the source of truth.
The console can wear your own brand, if it’s going in front of someone else’s team. The CLI and the resources on the cluster still say Omnia.