Ornith 1.0-397B: Self-Hosting vs API and When the Flagship Is Worth It

July 7, 2026 · 9 min read

Ornith 1.0-397B is the top open-source agentic coding model available as of 2026. It surpasses Claude Opus 4.7 on both Terminal-Bench 2.1 and SWE-Bench Verified, and it does so under an MIT license with freely downloadable weights. Those two facts together create a question: is it practically accessible, or just a benchmark trophy?

This guide covers the real infrastructure requirements for the ornith 397b, the cloud API options available for teams without in-house GPU clusters, and an honest assessment of when the 397B upgrade over the 35B is worth the cost.

Ornith 1.0-397B: What You Need to Know

Ornith 1.0-397B is a Mixture-of-Experts model with 397B total parameters, built on Qwen 3.5 397B and post-trained with DeepReinforce AI’s self-scaffolding reinforcement learning process. Like all Ornith 1.0 variants, it supports a 262,144-token context window and is MIT licensed.

At 397B MoE scale, the model activates a larger subset of experts per token than the 35B, giving it access to a vastly richer learned representation at the cost of requiring multi-GPU infrastructure. The full model family context is on the models page.

Ornith 1.0-397B Benchmark Results

All scores are from DeepReinforce AI’s official evaluation (self-reported):

The 397B sits clearly above Claude Opus 4.7 on the two primary agentic benchmarks: +7.2 points on Terminal-Bench 2.1 (77.5 vs 70.3) and +1.6 on SWE-Bench Verified (82.4 vs 80.8). Claude Opus 4.8 still leads with 85 and 87.6 respectively — and GLM-5.2-744B scores 81.0 on Terminal-Bench. See the full benchmarks comparison for the complete picture including smaller model scores.

The practical implication: ornith 397b is the best open-source option for teams that need frontier-level agentic coding performance with self-hosted deployment.

Self-Hosting Requirements: The Real Hardware Picture

Ornith 1.0-397B VRAM requirements:

DeepReinforce AI’s official recommendation is 8× 80GB GPUs for comfortable FP8 serving, which aligns with a standard 8-card H100/A100 server. The FP8 quantization halves memory requirements compared to bf16 while retaining the vast majority of accuracy.

At the current market rate cited on the how-to-run page, an A100 80GB from RunPod starts at around $1.19/hr. Running 8× A100s for a full day of inference works out to roughly $228 in cloud GPU costs — meaningful but within reach for production agent pipelines where the alternative is a cloud API with per-token pricing.

vLLM Setup for 397B Multi-GPU

vllm serve deepreinforce-ai/Ornith-1.0-397B \
--served-model-name Ornith-1.0-397B \
--host 0.0.0.0 --port 8000 \
--tensor-parallel-size 8 \
--max-model-len 262144 \
--dtype fp8 \
--gpu-memory-utilization 0.90 \
--enable-prefix-caching \
--enable-auto-tool-choice --tool-call-parser qwen3_xml \
--reasoning-parser qwen3 \
--trust-remote-code

The --tensor-parallel-size 8 flag distributes the model across 8 GPUs. Adjust to match your available card count; a minimum of 3× 80GB cards is required for FP8. Enable prefix caching with --enable-prefix-caching to speed up agent loops that share long system prompts across turns.

SGLang Setup for 397B

python -m sglang.launch_server \
--model-path deepreinforce-ai/Ornith-1.0-397B \
--tp 8 \
--context-length 262144 \
--mem-fraction-static 0.85 \
--tool-call-parser qwen3_coder \
--reasoning-parser qwen3

SGLang’s MoE-optimized scheduling can deliver higher throughput than vLLM for batch inference workloads. Both frameworks expose an OpenAI-compatible API endpoint.

Cloud API Options for Ornith 397B

Not every team has or wants 8× A100s in-house. Cloud providers and inference services are increasingly hosting the large open-source frontier models, and Ornith 1.0-397B is likely to appear on platforms that host Qwen, Llama, and similar large models.

For current availability, check:

• Hugging Face Inference Endpoints — allows deploying any HF model on demand
• Managed GPU cloud providers (RunPod, Vast.ai, Lambda Labs) — spin up an 8-card server and run vLLM yourself
• Community inference providers that update their model catalogs when major releases drop

The Hugging Face model ID is deepreinforce-ai/Ornith-1.0-397B. If your preferred inference provider supports custom HF model loading, this is the path to using 397B without managing your own cluster.

Connecting 397B to Coding Agents

Once your ornith 397b api server is live, connecting it to agent frameworks follows the same pattern as smaller models:

# Claude Code
export OPENAI_BASE_URL="http://your-server:8000/v1"
export OPENAI_API_KEY="EMPTY"

# OpenHands
export LLM_MODEL="openai/deepreinforce-ai/Ornith-1.0-397B"
export LLM_BASE_URL="http://your-server:8000/v1"
export LLM_API_KEY="EMPTY"
openhands

Tool calling is enabled in the serve command; no additional agent-side configuration is needed.

When Is the 397B Worth It vs the 35B?

This is the central decision for most teams. The 35B MoE delivers impressive results at a single-consumer-GPU cost. The 397B requires a multi-GPU server. Here is how to think about the trade-off:

The 397B Earns Its Cost When:

High-volume production pipelines: If your CI/CD runs hundreds of agent tasks daily and each percentage-point accuracy improvement translates to fewer failed PRs or reduced engineer review time, the 397B’s accuracy premium pays for itself.

Complex, multi-file refactors: The accuracy gap between 35B and 397B is most pronounced on the hardest tasks — the SWE-Bench Pro differential (44.6 for 35B vs 62.2 for 397B) reflects this. Production codebases with deep interdependencies benefit more from the larger model.

Enterprise privacy requirements: Organizations that need frontier-level accuracy without sending code to a third-party API can justify the hardware. The 397B’s benchmark position (above Opus 4.7, close to Opus 4.8) means you get near-frontier quality from an on-premises deployment.

Research and benchmark work: If you are comparing open-source model performance, the 397B is the relevant data point for state-of-the-art open coding capability.

The 35B Is Sufficient When:

• Your tasks are scoped to single-file edits, targeted bug fixes, or well-defined functions
• You are running an individual developer workflow rather than a team pipeline
• You have 24 GB GPU access but not a multi-GPU cluster
• Iteration speed matters more than maximum accuracy on each run

The ornith 9b vs 35b comparison covers the lower end of the range. For the 35B-vs-397B question, benchmark on your actual codebase tasks — the SWE-Bench and Terminal-Bench numbers give a general signal, but real-world task distributions vary.

The Self-Scaffolding Advantage at 397B Scale

At 397B scale, the self-scaffolding RL training reaches its full expression. DeepReinforce AI describes the training process as jointly optimizing both the solution code and the orchestration scaffold — the task plan, tool call sequence, error recovery, and replanning logic. At 397B parameters:

• The model can maintain coherent state across significantly longer tool-call chains
• Task decomposition is more fine-grained and context-aware
• Error recovery is more sophisticated — the model diagnoses failure modes rather than simply retrying
• Cross-file dependency reasoning is more reliable at repository scale

These behaviors are hard to quantify with a single benchmark number, but they compound across long agent sessions in ways that explain why the Terminal-Bench gap between 35B (64.2) and 397B (77.5) is so large — a 13-point difference on a benchmark where each point represents meaningful agent capability improvement.

Anti-Reward Hacking at 397B

One concern with large RL-trained models is benchmark gaming. DeepReinforce AI addresses this with three explicit safeguards:

1. Fixed trust boundary: limits what the model can access during RL training
2. Deterministic monitor: flags suspicious pattern exploitation
3. Frozen LLM judge: evaluates solution quality independently of the RL reward signal

These are described in the site’s FAQ. Independent verification of the 397B scores was pending as of mid-2026; the approach to anti-hacking is worth understanding before deploying the model in high-stakes production environments.

FAQ

How much does it cost to self-host Ornith 1.0-397B?

Hardware costs vary by provider. At roughly $1.19/hr per A100 80GB on RunPod, an 8-GPU setup costs around $9.52/hr. For intermittent workloads, spinning up on-demand cloud instances keeps costs proportional to usage. The key comparison is against API pricing for closed frontier models; if your usage is heavy, self-hosting quickly becomes cost-competitive.

Can I run Ornith 1.0-397B with fewer than 8 GPUs?

Yes, with trade-offs. In FP8 the model needs roughly 200 GB of VRAM. Three or four A100 80GB cards (240–320 GB total) are sufficient at FP8. Adjust --tensor-parallel-size to match your card count. Running on fewer, larger-VRAM cards (e.g., H100 141GB) also works.

What is the context length of Ornith 1.0-397B?

Like all Ornith 1.0 models, the 397B supports 262,144 tokens. Set --max-model-len 262144 in vLLM or --context-length 262144 in SGLang. The full 262K window requires careful KV cache management on multi-GPU setups; reducing context length can significantly improve throughput.

Is Ornith 1.0-397B available for commercial use?

Yes. DeepReinforce AI released all Ornith 1.0 models under the MIT license with no regional restrictions. The 397B can be used in commercial products and services without royalty obligations.

The Ornith 397B Verdict

The ornith 397b is a genuine frontier-class open-source model — the first open model to convincingly beat Claude Opus 4.7 on agentic coding benchmarks. The self-hosting requirements are real (8× 80GB GPUs recommended), but the MIT license and available cloud infrastructure make it accessible to any team with a serious production use case.

For developers and small teams, the 35B MoE remains the right choice. For organizations running production agent pipelines where maximum accuracy matters and API costs or privacy concerns rule out closed models, the ornith 397b api path — whether self-hosted or via cloud inference — is the most capable open-source option available in 2026. Compare the full model range on the models page or explore alternatives to understand where Ornith 397B sits in the broader landscape.