Open-Weight LLM · Private & Custom AI
Ornith-1.0-397B-FP8
Ornith-1.0-397B is a self-hosted, MIT-licensed coding-agent model for enterprises building private AI systems that automate software engineering and agentic task execution without sending code or data to external APIs.
Ornith-1.0-397B is a 397B-parameter Mixture-of-Experts (MoE) model optimized for agentic coding tasks—SWE-Bench, Terminal execution, repository navigation, and multi-step problem solving. Built on Qwen 3.5 and trained via self-improving RL, it achieves state-of-the-art results on coding benchmarks among open-weight models of comparable size. For ops teams, this means the ability to deploy a coding agent entirely on private infrastructure, automating code review, bug fixes, and developer tooling without vendor lock-in or external API calls.
Model facts
Private deployment
Run Ornith-1.0-397B-FP8 in your own environment
Ornith-397B is quantized to FP8 (estimated ~100–150 GB VRAM for inference) and designed for single-GPU deployment in customer data centers or private cloud environments. Running it self-hosted means code, pull requests, and internal repositories remain within your security boundary. This is essential for enterprises with IP sensitivity or compliance requirements; no model calls leave the customer's environment. Trade-off: you own the ops cost (hardware, inference pipeline optimization, failover), but gain full data control and audit visibility.
Operational AI use cases
Autonomous Code Review & Audit Agent
Integrate Ornith as an in-house code reviewer. Route pull requests, bug reports, and security tickets to the model running on private infrastructure. It analyzes diffs, suggests fixes, checks SWE-Bench-style test coverage, and flags issues without exposing your codebase to third-party services. Reduces manual review bottlenecks for mid-market dev teams.
Internal Developer Support & Documentation Bot
Deploy Ornith to answer internal engineering questions: 'How do I integrate this API?' 'What changed in the last sprint?' 'Debug this error stack.' The model understands repo structure (NL2Repo capability) and can navigate multi-file codebases. Runs on company infrastructure; no chat logs sent to OpenAI or Anthropic. Reduces Slack overflow and repetitive Jira ticket triage.
Ops Task Automation: Terminal-Based Workflow Agents
Use Ornith's Terminal-Bench 2.1 performance to automate DevOps and SRE workflows: deployments, log parsing, infrastructure diagnostics, and runbook execution. It can reason through multi-step terminal commands and generate safe execution plans for your team to review before running. Keeps sensitive system access logs and command histories private.
Custom AI
As a base for custom AI
Ornith-397B is a strong base for building proprietary coding-agent products. Fine-tune it on your internal codebase, domain-specific bug patterns, or custom dev tools using your own dataset (no data leaves your environment). Use it as the backbone for an internal IDE copilot, bug-fix automation system, or repo-aware knowledge retrieval layer. The MoE architecture and coding specialization mean faster iteration on domain adaptation than starting from a general-purpose LLM.
In the operating system
Where it fits
In an AI operating system, Ornith sits at the **agent and workflow automation layer**. It's the reasoning engine for code-focused autonomous agents. Feed it structured input (repo snapshot, ticket description, error logs) and get back actionable outputs: code diffs, test suggestions, terminal commands, or written documentation. Pair it upstream with retrieval/knowledge layers (to inject repo context) and downstream with execution/validation layers (to run or sandbox the suggested actions). Not a chat model—it's an automation backbone.
Data control & security
Self-hosting Ornith means your code, queries, and execution history never transit through external APIs—a critical architectural advantage for enterprises with IP sensitivity, regulatory audit requirements (SOC 2, HIPAA, PCI), or high-security environments. However, self-hosting alone does not guarantee security: you remain responsible for infrastructure hardening, model quantization integrity, access controls, and inference endpoint isolation. Use private VPC deployment, enable audit logging at the inference layer, and validate the model's behavior on your sensitive datasets before production rollout. No claims are made about differential privacy, adversarial robustness, or prompt injection resilience; assess these per your threat model.
Hardware footprint
**Estimate (FP8 quantization):** ~100–150 GB VRAM for batch-1 inference on a single GPU (e.g., 8× A100 80GB or single H100). At FP16: ~200+ GB (not practical single-GPU). Throughput varies by inference engine optimization; expect token/s targets lower than dense models due to MoE routing overhead. Verify on your actual hardware stack before committing to production; throughput benchmarks are absent from the provided data.
Integration
Ornith is available in Hugging Face `transformers` + `safetensors` format, compatible with vLLM, TGI, and ONNX inference engines. Wire it into your CI/CD pipeline via REST or gRPC endpoints (run vLLM behind FastAPI). For ops automation: call it from internal orchestration tools (Airflow, Temporal, Kubernetes CronJobs). For code review: integrate with GitHub/GitLab webhooks to trigger analysis on PRs. Use structured prompts (JSON-in, JSON-out) to enforce deterministic outputs for downstream automation. No built-in RAG or tool-calling; you'll layer those—embed your repo, provide context via prompt engineering, or fine-tune a smaller LoRA adapter for tool bindings (API calls, file ops).
When it's not the right fit
- —Your team needs sub-100ms latency or streaming chat-like interactions—Ornith's 397B parameter count and MoE routing add latency; better suited for batch agentic tasks than real-time user-facing chat.
- —You lack in-house infrastructure or Kubernetes expertise—self-hosting a 397B model requires non-trivial ops (GPU procurement, inference optimization, failover). Start with a 9B or 31B variant (smaller dense models in the family) if ops overhead is a blocker.
- —Context window is critical—the provided data does not specify Ornith-397B's context length. If you need long-document analysis or large repo processing, verify the window size and compare to alternatives.
- —Your codebase uses non-standard or niche programming languages—benchmarks focus on standard languages (Python, JS, etc.). Model behavior on Rust, Kotlin, or domain-specific languages is unknown.
Alternatives to consider
DeepSeek-Coder-V2 (236B, MoE)
Similar coding specialization and MoE efficiency, open-weight, but requires review of licensing terms and deployment maturity. Potentially lower throughput/hardware footprint than Ornith-397B.
Qwen3.5-397B (base model, not fine-tuned for coding)
Shares the same parameter count and base architecture as Ornith but is general-purpose. If you want flexibility beyond coding tasks (documentation, support automation) and don't need Ornith's RL-tuned agent capabilities, Qwen3.5 may offer slightly lower licensing friction and broader capability.
Llama 3.1 405B (dense, open)
Larger, fully open, strong general reasoning. Better for multi-domain ops automation, but no specialized coding training. Requires more VRAM (>400GB FP8). Lacks agentic RL tuning; you'd fine-tune from scratch.
Related open models
FAQ
Can we use Ornith-397B in a private, on-prem deployment without any data leaving our network?
Yes. MIT license permits self-hosting. Deploy it via vLLM or similar on your Kubernetes cluster or GPU servers. All inference, logs, and outputs stay in your environment. You manage infrastructure, scaling, and security posture.
What's the commercial use story? Can we build a product on top of Ornith and sell it?
MIT license is permissive for commercial use—you may build, modify, and monetize derivatives. You must include the MIT license notice in your product. Verify that your fine-tuning data and deployment don't introduce secondary restrictions (e.g., if you use GPL'd tools in your pipeline). No vendor lock-in; you own the model and weights.
How much faster is Ornith than fine-tuning or prompt-engineering with a smaller model?
Ornith's coding benchmarks (SWE-Bench 82.4%, Terminal-Bench 77.5–78%) suggest it solves hard tasks end-to-end without heavy prompt engineering. A smaller model (9B, 31B) would require more context injection and multi-step prompting. Trade-off: Ornith's latency and inference cost are higher; smaller variants are faster and cheaper but demand more engineering effort to reach the same accuracy.
Is context window a blocker for our large codebases?
Unknown—Ornith's context length is not disclosed in the model card. Before commit, request specs from deepreinforce-ai. If insufficient, plan to use retrieval (vector DB of code snippets) or repo summarization to feed the model relevant context.
Build Your Own Code Agent. Keep Data Private.
Ornith-397B is a foundation for enterprises to deploy autonomous coding and ops agents entirely on private infrastructure. LLM.co helps you integrate it into your stack—infrastructure setup, fine-tuning, ops automation pipelines, and continuous deployment. Start building custom AI that runs in your environment. Let's talk.