OpenAI Amp Review, the Builder's Verdict on a General Agent

Amp's move beyond code is getting covered as a model launch, and that framing will cost you money if you take it literally. This OpenAI Amp review reads the same news differently. The stack of GPT-6 Astra, Ultrafast, and GPT-Live-1 is the visible half, but the structural change is Sign in with ChatGPT turning an agent from a tool you drive into a worker you authorize and audit. Once an agent holds delegated identity, the interesting questions stop being about benchmark scores and start being about which model carries which duty, what a long agent loop actually costs, and who is accountable when it touches your production systems.

This piece answers those three questions in order, then maps five non-code workloads onto the stack and closes with an adopt-or-pass rubric you can apply to your own team this week.

What Amp's beyond-code repositioning actually changes

OpenAI's launch post presents Amp going beyond coding with four components: the Astra frontier model, the Ultrafast fast-decode mode, the GPT-Live-1 realtime model, and Sign in with ChatGPT. Three of those four are models or model modes. The fourth is the one that changes what your agent is.

A coding agent already operated inside a generous permission envelope: your repository, your terminal, your CI. Repositioning Amp as a general agent platform means the envelope now covers your email, your ticketing queue, your cloud console, and your vendor portal. Every one of those is an AI agent identity and permissions problem before it is a model problem.

So the load-bearing change is delegated ChatGPT sign-in, not Astra. Models determine what the worker can do. Delegated identity determines whether you can authorize it narrowly, attribute every action it takes, and revoke it cleanly when something goes wrong. Treat this launch as an identity and permissions shift with a model stack attached, and the rest of the analysis falls into place.

The model stack as a duty roster

The useful mental model for the stack is a duty roster, not a leaderboard. Each tier earns its slot by carrying one kind of step inside the agent loop, and the routing rule is simple: route by step type, not task type. Model routing for agent planning versus execution is where most of the economics and most of the quality live.

Two claims in that table deserve their own justification. First, frontier reasoning capacity such as GPT-6 Astra pays off mainly at planning, decomposition, and verification. A bad plan poisons thirty downstream steps; a slightly weaker summary of step twelve poisons nothing you will notice. Second, routine substeps often show little measurable gain from frontier capacity. Formatting an API response into a table or composing a routine tool call is decode work, and paying frontier rates for it is the single most common way to burn money on a general agent.

What fast decode and realtime buy inside an agent loop

A chat turn and an agent loop spend latency differently, and that difference is the whole cost story. A chat turn is one burst of decoding. A thirty-step agent loop is thirty bursts plus tool waits, and the decode time compounds across every step.

Long-running loops are typically decode-bound: most of the run's wall-clock goes to generating output tokens, not to waiting on tools or scoring prompts. Do the arithmetic with stated assumptions. If a task needs 30 substeps and each emits roughly 1,500 output tokens, the run generates about 45,000 tokens before you count a single tool call. When decode dominates, a fast-decode mode that generates output substantially faster shortens the loop roughly in proportion, and the Ultrafast decoding guide is the official reference for which models the mode supports. The same routing usually cuts spend too, because mechanical steps move off frontier per-token pricing. A fast-decode tier can therefore cut per-task cost and wall-clock more than upgrading every step to the frontier model would, which is the counterintuitive part for anyone who assumes better means Astra everywhere.

Realtime inverts the logic. Where GPT-Live-1 earns its keep in an agent workflow is approvals, live clarification when the agent is genuinely stuck, and handoffs to a human mid-run, which is why GPT-Live-1, documented as a realtime model for live speech, is the checkpoint tier, not the workhorse tier. Holding a realtime channel open across an entire run is rarely worth the premium, because the channel earns nothing while the agent churns through mechanical steps alone.

The main cost failure mode is tier misrouting: running mechanical substeps at frontier pricing, or worse, whole runs on a realtime channel. Route by step type and the stack behaves. Route by task type and you pay frontier rates for formatting.

Sign in with ChatGPT as the identity layer

The Sign in with ChatGPT quickstart walks through a familiar shape: your app redirects a user, they approve with their ChatGPT account, and your app receives delegated credentials. That is the delegated-authorization pattern that OAuth 2.0 standardized, and it is a solid base for agent identity, because scopes, refresh tokens, and revocation are all native to the vocabulary. For builders, this removes the worst part of general-agent work, which is hand-rolling an auth and permission stack for every tool the agent touches.

What delegated identity buys

What delegated identity buys you is attribution. When the agent acts in your ticketing system or your cloud account, the action maps to a principal you authorized, with scopes you granted, in a session you can end. That is the difference between auditing a worker and guessing what a script did.

The catch is what it couples you to. Because sign-in runs through ChatGPT accounts rather than your corporate directory, enterprise permissions and audit for a delegated agent appear to rest on OpenAI's identity layer until SSO and SCIM support are confirmed. If your security posture requires SSO through your own IdP, automated provisioning per the SCIM specification, or exportable audit logs as compliance evidence, verify each control exists before regulated adoption. Depending on which controls Amp actually exposes, some will be missing today, and that gap alone can decide the verdict.

Before you delegate identity, get written answers to five questions:

• Which permission scopes exist per integration, and can they be narrowed per agent?
• Are sessions revocable per user without killing unrelated agents?
• Is there an audit log you can export, and what is its retention window?
• Does access flow through SCIM provisioning from your directory, or through manual invites?
• Do agent transcripts and tool payloads fall under the retention rules in OpenAI's API data controls, and do they qualify for stricter treatment?

This checklist is not paranoia. The NIST AI Risk Management Framework treats human oversight and accountability as first-class controls, which is exactly the posture a delegated-identity worker demands. An agent that can touch five systems needs governance designed for five systems.

Five non-code workloads mapped to the stack

General-agent work is not a new category. The GAIA benchmark has been evaluating assistants on real-world tasks that require tool use, multi-step reasoning, and navigation of messy sources for years, which is the cleanest evidence that this class of work predates Amp. What is new is a coding-grade agent with delegated identity attempting it. The rest of this OpenAI Amp review tests the claim by mapping five non-code workloads onto the stack, and the two most contested rows get a step-split walkthrough so you can see exactly where each verdict comes from.

Weekly ops reporting, the adopt case step by step

Monday morning, six SaaS dashboards, one report due at ten. Ultrafast pulls the metrics from each tool and formats them into a working draft, which is the mechanical bulk of the run. Astra interprets the numbers once, flags the anomaly that deserves a sentence of explanation, and verifies the summary against source figures rather than against the draft's own claims. GPT-Live-1 checkpoints the one irreversible step, the send to the leadership channel, where a wrong number travels further than any correction. Every system involved is read-heavy, the permission scopes are narrow, and a mistake costs embarrassment rather than a compliance finding. Adopt.

Regulated finance aggregation, the pass case step by step

Same shape on the surface, opposite verdict underneath. Ultrafast pulls balances and invoices, Astra reconciles categories and verifies the ledger mapping, GPT-Live-1 would carry the one irreversible step, the journal entry that posts to the books. The model work is not the problem, and that is the point: payroll and billing systems sit behind SSO through the company IdP, the run needs provable deprovisioning when a teammate leaves, and every query must leave exportable evidence a compliance team can produce on request. Those are precisely the gaps the identity section flagged. Until they close, this workload belongs to internal tooling you already govern, whatever the stack could theoretically do.

Notice that the two rows run the same tiers through the same kinds of steps, and the verdict flips on the permission boundary alone. Model capability is not the variable; governance reach is. The adopt cases share a signature: multi-system, permission-gated, long-horizon work where most steps are mechanical and a few steps carry real judgment. That signature is also the routing plan, and you do not need to reinvent it per workflow.

Adopt or pass, the OpenAI Amp review rubric

The coding agent vs general agent comparison resolves cleanly once you follow permission boundaries and latency sensitivity rather than capability hype. When to use a general agent instead of a coding agent comes down to one sentence: if the work spans systems the agent must be authorized into, use the general platform; if the work lives inside your editor's feedback loop, keep the coding agent.

Amp versus coding-only agents, side by side

For latency-sensitive, IDE-bound coding, coding-only agents often still win, and pretending otherwise would be hype. Amp's advantage appears in multi-system, long-horizon work that spans code and non-code tools, which is precisely the work coding agents were never shaped to do. Adopt on the right side of that line and pass on the wrong side.

Limits, unknowns, and what to watch

Four unknowns could move this verdict, and honesty about them is part of it.

• Routing control. Whether you can pin a tier to a step, or Amp decides internally, determines whether the duty roster is a plan you execute or a hope you hold.
• Pricing at scale. Long loops amplify both wins and mistakes; published per-tier economics under sustained agent load are what make the cost claims testable rather than directional.
• Rate limits and queueing. A general platform that touches many SaaS APIs inherits their limits; behavior under bursty multi-tool load is undocumented in anything a builder can plan against.
• Audit maturity and lock-in. Exportable logs and retention controls decide regulated adoption, and binding your agent's identity to one provider is a coupling to price consciously.

Each has a watch signal: a routing API, published agent-tier pricing, documented rate limits, log export, SCIM support. Any two arriving would upgrade the verdict for a regulated team. None arriving within your evaluation window is your answer.

The builder's verdict

By reader type: solo builders and small engineering teams with low-regulation workloads should pilot Amp now, because the permission model plus tiered routing is something a small team would need a quarter to assemble on their own. Teams whose systems sit behind SSO, SCIM, or audit mandates should wait, not because the models are inadequate but because the identity layer has not yet earned regulated trust.

If you pilot, take three steps. Pick one workload with a clean permission boundary, weekly ops reporting being the safest. Route it per the duty roster and log which tier carried each step, so you can compare cost and wall-clock against your current process after a few runs. Put a GPT-Live-1 checkpoint at the one irreversible step, then widen scope only after two clean cycles.

The architecture is worth adopting where you can audit it, worth routing deliberately wherever you do, and worth passing on wherever identity requirements still outrun the platform. That is the whole verdict, and it fits on one line because the reasoning behind it now fits in your head.