Amp Pushes Agents Past Code With GPT-6 Astra and GPT-Live-1

OpenAI published a customer story about Amp on October 14, and the most useful detail in it is not a benchmark number. It is that a 20-person company runs its marketing with an agent instead of a marketer, that some Amp users go through 10 billion tokens in a week, and that Amp's CEO thinks a visible token counter is exactly what stops teams from discovering what an agent can do. Underneath that is a routing decision: GPT-6 Astra for long-horizon work, writing and design, GPT-Live-1 for realtime voice, and an Ultrafast mode for latency-sensitive edits. Three models, three different jobs, one product.

Agents stopped being autocomplete a while ago. Routers are how you notice.

What the story actually describes

Amp is a coding agent built by the people behind Sourcegraph, and CEO Quinn Slack frames each model improvement as extra room for the agent, from helping developers decide what to build through to writing code and designing pages. OpenAI models make up the majority of tokens used in Amp. The concrete pieces named in the story are GPT-6 Astra, which the team uses for documentation and design pages that have to match a picky house style, GPT-Live-1, which powers Calling Puck so users can talk to Puck in real time, and an Ultrafast mode that Amp has been testing with Astra. Puck itself is worth noting: it is a conversational assistant inside Amp whose job is launching and managing other agents. The product is not one agent, it is a console for a fleet, and the models are chosen per job rather than per company.

# Three jobs, three models. Routing lives in a table so a reviewer can read it.
ROUTES = {
    "plan_next_milestone": {"model": "gpt-6-astra", "mode": "standard", "why": "long horizon, quality first"},
    "write_docs_and_landing": {"model": "gpt-6-astra", "mode": "standard", "why": "voice and design consistency"},
    "edit_open_file": {"model": "gpt-6-astra", "mode": "ultrafast", "why": "a human is waiting keystroke by keystroke"},
    "voice_control_fleet": {"model": "gpt-live-1", "mode": "realtime", "why": "turn taking, not batch"},
}

def route(task, latency_budget_ms=None):
    plan = ROUTES.get(task)
    if plan is None:
        return {"model": "gpt-6-astra", "mode": "standard", "why": "unclassified task, take the careful path"}
    if latency_budget_ms is not None and latency_budget_ms < 2000 and plan["mode"] == "standard":
        return {**plan, "mode": "ultrafast", "why": "latency budget forces the fast path"}
    return dict(plan)

print(route("edit_open_file"))
print(route("write_docs_and_landing", latency_budget_ms=1500))

# A model choice made in a code review comment is a model choice nobody can audit later.

The token counter is a product decision

Slack describes users consuming 10 billion tokens a week, and says watching every increment of usage can hold people back from finding out what an agent is capable of. That is why Amp shipped a Sign in with ChatGPT integration: it gives users more tokens and wider access to OpenAI models, Astra included, which changes how willing people are to hand over a larger task. This is the part worth stealing. If your platform meters aggressively, you will see conservative usage and conclude the agent is not that capable. The honest move is to pick a budget you can afford and then stop staring at it inside the product.

# A fleet budget you can read out loud once a week beats a surprise invoice.
from collections import defaultdict

WEEKLY_CAP = 5_000_000_000

class Fleet:
    def __init__(self, cap=WEEKLY_CAP):
        self.cap = cap
        self.spent = 0
        self.by_agent = defaultdict(int)

    def charge(self, agent, tokens):
        self.spent += tokens
        self.by_agent[agent] += tokens
        share = self.spent / self.cap
        verdict = "allow" if share < 0.85 else "throttle" if share < 1.0 else "stop"
        return {"agent": agent, "spent": self.spent, "used_pct": round(share * 100, 2), "verdict": verdict}

fleet = Fleet()
for agent, tokens in [("planner", 1_200_000_000), ("marketing", 800_000_000), ("docs", 2_600_000_000)]:
    print(fleet.charge(agent, tokens))

print(dict(sorted(fleet.by_agent.items(), key=lambda kv: -kv[1])))

# The marketing agent is the one nobody budgets for. Watch that line first.

A weekly token curve tells you more about an agent platform than a launch post

Routing belongs in a table, not in a reviewer's memory

Once you accept that different jobs need different models, the next question is where that decision lives. In a chat thread it lives nowhere. In a table it lives in the repository, which means a change to it shows up in review. The table below maps a task to a model, a mode and a one-line justification. The interesting branch is the latency one: when someone is waiting keystroke by keystroke, a careful model in a slow mode is the wrong answer even if it is the better model.

# Voice is a dispatcher. Keep the transcript, the intent and the spawned agent together.
import re

INTENTS = [
    (re.compile(r"\b(start|launch|spawn)\b.*\b(bug|investigat\w*|debug)\b", re.I), "debug_agent"),
    (re.compile(r"\b(coordinate|orchestrate)\b.*\bagents?\b", re.I), "orchestrator"),
    (re.compile(r"\b(find|recall|search|where)\b.*\b(conversation|thread|earlier)\b", re.I), "history_search"),
]

def dispatch(transcript):
    for pattern, action in INTENTS:
        if pattern.search(transcript):
            return {"action": action, "transcript": transcript, "confirmed": False}
    return {"action": "clarify", "transcript": transcript, "confirmed": False}

for line in [
    "start an agent to investigate the flaky checkout test",
    "coordinate the agents working on the migration",
    "where did we talk about the retry bug earlier",
]:
    print(dispatch(line))

# confirmed=False on purpose. A command spoken into a watch should be cheap to undo.

Voice is an interface to a fleet, not a feature

Calling Puck lets users talk to Puck in real time, including from a watch, and Slack's example is keeping agents working while you are away from the computer. That framing matters. Voice here is not dictation and it is not a chatbot upgrade. It is a dispatcher for background workers: start an agent, coordinate several, find an earlier thread. If you build the same thing, treat a spoken command as an intent plus a confirmation step, not as an action that executes on the strength of an imperfect transcript. Voice recognition fails quietly, and a fleet does not.

# Faster round trips buy you a second pass. Spend that budget deliberately.
def plan_for(round_trip_ms, wall_clock_budget_ms, max_passes=3):
    passes = 0
    remaining = wall_clock_budget_ms
    while remaining > round_trip_ms and passes < max_passes:
        passes += 1
        remaining -= round_trip_ms
    return {
        "round_trip_ms": round_trip_ms,
        "max_passes": passes,
        "leftover_ms": remaining,
        "strategy": "self-critique before returning" if passes >= 2 else "return on the first pass",
    }

print(plan_for(round_trip_ms=1800, wall_clock_budget_ms=12000))
print(plan_for(round_trip_ms=400, wall_clock_budget_ms=12000))

# When models got fast, the useful question stopped being "how many agents" and became
# "how much checking can I afford before the human loses interest".

Amp runs marketing with an agent and no dedicated marketer. Write that decision down.

Speed changes behaviour, not just latency

Amp has been testing Ultrafast mode with GPT-6 Astra, and Slack's observation is behavioural rather than technical: today people spread themselves across several agent tasks while waiting, and faster responses could mean juggling fewer agents or letting agents spend the saved time checking their own work. That is a nice way to think about your wall-clock budget. If a round trip drops from 1.8 seconds to 0.4 seconds, you have not merely improved a metric, you have bought two extra review passes inside the same patience window. Whether to spend them is a deliberate choice, and the code below makes it an explicit one.

# Amp's own framing: pull the work before and after code into the agent too.
WORKFLOW = [
    ("decide_what_to_build", "product", ["read_issues", "draft_options", "estimate_risk"]),
    ("write_the_code", "engineering", ["edit_files", "run_tests"]),
    ("grow_the_product", "marketing", ["rewrite_docs", "improve_onboarding", "draft_search_copy"]),
]

def handoff(workflow, owner_map=None):
    owner_map = owner_map or {}
    rows = []
    for stage, function, tools in workflow:
        rows.append({
            "stage": stage,
            "function": function,
            "tools": tools,
            "human_owner": owner_map.get(function, "unassigned"),
        })
    return rows

for row in handoff(WORKFLOW, {"engineering": "on-call", "product": "founder"}):
    print(row)

# An agent covering a function with no human owner is a decision. Write it down.

The part to copy on Monday

Three things travel well. First, write your model routing down as configuration, with a reason per row, so the decision survives the person who made it. Second, budget the fleet weekly with per-agent attribution, because the agent that blows the budget is usually one nobody thinks of as a compute consumer. Third, keep spoken commands reversible. Amp's own next step is bringing more of the work before and after coding into the agent so builders can carry an idea further without handling every step. That is a product roadmap, but it is also a decent test for your platform: can one person start something on Monday and still recognise it on Friday?