One family. Three models. Built for every scale.

Flagship reasoning for work where getting it wrong is expensive.

Magma is 4RGED’s highest-capability model. It is built for long-horizon plans, hard trade-offs, and multi-step agent runs where depth matters more than raw speed.

What it does well

• Frontier-depth reasoning

  Handles ambiguous requirements, conflicting constraints, and multi-hop decisions without shortcutting to a shallow answer.

• Architecture & planning

  Breaks large changes into sequenced steps, surfaces risks early, and keeps system-wide context across long sessions.

• Multi-step agent execution

  Stays coherent across tool calls, retries, and verification loops — built for agents that must finish the job, not just draft a reply.

• High-stakes review quality

  Stronger at catching policy, security, and correctness issues before they land in production.

Choose this when

Complex reasoning, architecture decisions, and critical agent workloads.

• The cost of a wrong architectural choice outweighs Magma’s higher unit price.
• You need deep, multi-file or multi-service plans — not a single-file patch.
• Your agents run long tool chains and must preserve intent across many steps.
• You are reviewing security-sensitive or regulated changes.

Customer use cases

• System design & architecture reviews

  Evaluate trade-offs across services, data stores, and rollout plans with explicit risks and alternatives.

• Long-horizon coding agents

  Drive agents that research, edit, test, and revise across a large codebase before proposing a merge-ready change.

• Hard refactors & migrations

  Plan and execute migrations where order-of-operations and compatibility matter as much as the code itself.

• Policy, security & correctness review

  Pressure-test PRs and agent output for subtle failures, unsafe patterns, and compliance gaps.

The production default — strong coding agents at a lower unit cost.

Blaze is the workhorse of the 4RGED family: excellent coding and agent quality with enough headroom for real production systems — without Magma pricing on every request.

What it does well

• Production coding quality

  Writes, edits, and explains code with strong repo awareness — tuned for IDE pair-programming and review loops.

• Reliable under load

  Built for everyday production traffic: consistent behavior across many sessions, orgs, and agent types.

• Agentic orchestration

  Coordinates tools, tests, and multi-agent workflows without needing flagship pricing on every turn.

• Fast enough for interactive work

  Responsive for IDE and Cloud sessions where engineers are waiting on the next edit or answer.

Choose this when

Production workloads, coding agents, and day-to-day orchestration.

• You want one default model for IDE, Cloud, and CI agents.
• Coding quality matters, but Magma-level depth is not required on every call.
• You run many parallel agent sessions and need predictable cost.
• You need a million-token context window for real repositories and tickets.

Customer use cases

• IDE pair-programming agents

  Inline edits, explanations, and multi-file changes while an engineer stays in flow.

• Cloud parallel agent fleets

  Spin up many agents on tickets, PRs, or migrations without flagship cost on each run.

• CI, CLI & automation

  Fix failing checks, generate patches, and drive scripted workflows from the terminal or pipelines.

• Team default for new projects

  Standardize on one model so policy, prompts, and evals stay simple across the org.

Maximum context and throughput for everyday high-volume work.

Ember is optimized for scale: the largest context window in the family at the lowest price — ideal when you need to read a lot, respond quickly, and run many jobs.

What it does well

• High-throughput responses

  Built for queues and interactive chat where latency and cost per request dominate.

• Large document & dataset intake

  Ingest long docs, transcripts, and dumps in fewer passes — less glue code, fewer missed sections.

• Efficient long-context processing

  2M input and output context for jobs that would otherwise require aggressive truncation.

• Smart routing front door

  Classify and escalate: Ember handles volume; Magma or Blaze take the hard cases.

Choose this when

Everyday chat, summaries, triage, and high-volume long-context jobs.

• You process large documents or long conversations in a single request.
• Unit economics matter more than maximum reasoning depth.
• You need the fastest turnaround in the 4RGED family.
• You want a cheap first-pass model before escalating to Blaze or Magma.

Customer use cases

• Customer & internal chat assistants

  Fast answers across long histories without burning Magma or Blaze budget on every message.

• Summaries & briefings

  Collapse tickets, meetings, and docs into actionable notes at high volume.

• Classification & triage pipelines

  Label, route, and prioritize incoming work before a deeper model gets involved.

• Large-context ingestion

  Pull big files and datasets into agents for search, extract, and transform workflows.