AMP

When you pay for something online, your checkout doesn't talk directly to your bank. It talks to Stripe. Stripe validates the transaction, applies rules, and returns approved or declined. Your checkout never touches the payment logic.

AMP works the same way. Your agent doesn't execute consequential actions directly. It sends a signal to runshift. runshift validates it against operator rules and returns approved, rejected, or pending. Your agent never touches the gate logic.

Stripe is in the payment path. runshift is in the agent execution path. Neither controls your code.

your agent runs
  → task finishes
  → POST /amp/signal with AMP payload
  → gate fires if gate_required: true
  → operator approves/rejects
  → your agent receives resolution

your agent runs
  → routes model call through runshift proxy
  → runshift evaluates against operator rules
  → gate fires if conditions met
  → returns 202 + gate_id to your agent
  → operator approves/rejects
  → runshift POSTs resolution to your webhook
  → your agent continues or halts

import anthropic

# One line change — route through runshift proxy
client = anthropic.Anthropic(
    api_key="...",
    base_url="https://api.runshift.ai/v1/proxy"
)

# Your existing code works unchanged
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "..."}]
)

{
  // identity
  "amp_version":     "1.0",
  "agent_id":        "resume-tailor",
  "run_id":          "run_01jt4k...",
  "project_id":      "job-search",

  // execution
  "status":          "completed",
  "summary":         "Rewrote resume for Senior PM role at Stripe",
  "proposed_action": "Send to applicant",
  "artifacts":       [],
  "model":           "claude-sonnet-4-6",
  "input_tokens":    1842,
  "output_tokens":   614,
  "cost_usd":        0.007532,
  "started_at":      "2026-03-06T22:10:38Z",
  "completed_at":    "2026-03-06T22:10:46Z",
  "metadata": {
    "candidate_id":  "123",
    "source":        "manual relay prompt"
  },

  // governance
  "gate_required":   true,
  "webhook_url":     null
}

summary vs proposed_action. summary is what the agent already did — a record. proposed_action is what happens next if the operator approves — a proposal. relay shows both in the gate slide.

gate_required. Deterministic trigger. Your agent sets it. Operator rules in runshift confirm it. Both must be true for a gate to fire — agent declaration + operator authorization.

import requests, time, uuid

def resume_tailor(job_description: str, resume: str) -> str:
    """Your existing agent — unchanged."""
    start = time.time()

    # ... your agent logic ...
    result = rewrite_resume(job_description, resume)
    input_tokens = 1842
    output_tokens = 614

    # ── AMP: one call, agent is live ──
    requests.post("https://runshift.ai/amp/signal",
        headers={"Authorization": "Bearer rs-amp-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},
        json={
        "amp_version":     "1.0",
        "agent_id":        "resume-tailor",
        "run_id":          str(uuid.uuid4()),
        "project_id":      "job-search",
        "status":          "completed",
        "summary":         f"Rewrote resume for {job_description[:60]}",
        "proposed_action": "Send tailored resume to applicant",
        "artifacts":       [{"type": "text", "content": result}],
        "model":           "claude-sonnet-4-6",
        "input_tokens":    input_tokens,
        "output_tokens":   output_tokens,
        "cost_usd":        calculate_cost("claude-sonnet-4-6", input_tokens, output_tokens),
        "gate_required":   True,
        "started_at":      format_iso(start),
        "completed_at":    format_iso(time.time()),
        "metadata":        {"source": "manual relay prompt"},
    })

    return result

summary vs proposed_action. summary is what the agent already did — a record. proposed_action is what happens next if the operator approves — a proposal. relay shows both in the gate slide.

// gate_required: true → pending until operator decides
{
  "status":  "pending",
  "gate_id": "gate_01jt...",
  "message": "Awaiting operator approval"
}

// operator approved
{
  "status":  "approved",
  "gate_id": "gate_01jt...",
  "message": "Gate approved by operator"
}

// operator denied
{
  "status":  "rejected",
  "gate_id": "gate_01jt...",
  "message": "Gate rejected by operator"
}

// Pattern 2: runshift POSTs this to your webhook_url on resolution
{
  "gate_id":     "gate_01jt...",
  "status":      "approved",
  "run_id":      "run_01jt4k...",
  "agent_id":    "resume-tailor",
  "resolved_at": "2026-03-06T22:11:14Z",
  "resolved_by": "operator"
}

Start, stop, and manage agents from the runshift dashboard — this is a product capability, not an AMP protocol concern. See the roadmap for when agent lifecycle management arrives in the protocol.

export const MODEL_PRICING: Record<string, { input: number; output: number }> = {
  // Anthropic (per 1M tokens)
  'claude-sonnet-4-6':           { input: 3.00,  output: 15.00 },
  'claude-haiku-4-5':            { input: 0.80,  output: 4.00  },
  'claude-opus-4-6':             { input: 15.00, output: 75.00 },

  // OpenAI (per 1M tokens)
  'gpt-4o':                      { input: 2.50,  output: 10.00 },
  'gpt-4o-mini':                 { input: 0.15,  output: 0.60  },
  'o3':                          { input: 10.00, output: 40.00 },

  // Google (per 1M tokens)
  'gemini-2.5-pro':              { input: 1.25,  output: 10.00 },
  'gemini-2.5-flash':            { input: 0.15,  output: 0.60  },
}

export function calculateCost(
  model: string,
  inputTokens: number,
  outputTokens: number,
): number {
  const pricing = MODEL_PRICING[model]
  if (!pricing) return 0
  return (inputTokens / 1_000_000) * pricing.input
       + (outputTokens / 1_000_000) * pricing.output
}

v1 trust model. relay accepts agent-reported cost and may independently verify when model pricing metadata is available.