Open-Weight LLM · Private & Custom AI
Ornith-1.0-397B
Agentic coding backbone for private deployments: 397B MoE model purpose-built to automate software engineering workflows and terminal tasks without sending code to external APIs.
Ornith-1.0-397B is a 397-billion-parameter mixture-of-experts model fine-tuned on Qwen 3.5 for agentic coding tasks—SWE-bench, terminal automation, code generation, and repository navigation. For ops teams and custom AI builders, it's a self-contained alternative to closed coding agents (Claude, DeepSeek), designed to run on-premises and control all code/execution context.
Model facts
Private deployment
Run Ornith-1.0-397B in your own environment
Self-hosting is the primary deployment mode: the model runs on 4–8× H100/A100 GPUs (80GB VRAM) in int8/quantized form, or single/dual-GPU with aggressive quantization (4–8 bit). All code, terminal output, and repo context stays in your infrastructure—critical for enterprises with IP sensitivity or compliance constraints. No external API calls; full operational ownership.
Operational AI use cases
Autonomous Code Remediation & Bug Triage
Ingest error logs, stack traces, and code diffs. Ornith generates fix proposals, runs them against test suites in a sandbox, and routes validated patches to engineering teams. Reduces MTTR on routine bugs and security hotfixes; keeps code internal throughout.
Repository Navigation & Onboarding Automation
New engineers or ops staff query internal codebases via natural language ("Show me how user authentication works"). Ornith maps code structure, pulls relevant files, and generates walkthroughs—eliminating manual documentation debt. Context never leaves your network.
Compliance & Audit Log Analysis
Parse deployment logs, access control records, and config drift. Ornith identifies anomalies (unauthorized changes, missing annotations) and drafts audit summaries. Self-hosted means sensitive logs never touch third-party infra; useful for SOC2/FedRAMP-adjacent workflows.
Custom AI
As a base for custom AI
Strong foundation for building proprietary coding assistants, internal DevOps agents, or domain-specific code-gen tools. The model's self-improving RL framework (optimizes both solution and search strategy) is documented but requires custom implementation; teams can fine-tune Ornith on private codebases, internal APIs, and company-specific patterns. MoE architecture allows selective activation—good for cost-aware inference when integrated into a larger custom application.
In the operating system
Where it fits
Sits at the **agentic agent layer** of an ops-AI stack: ingests unstructured prompts (bug descriptions, code reviews, terminal tasks), reasons over codebase/logs, and outputs executable plans or code. Pairs with a workflow orchestration layer (to manage test-run loops, approval gates, deployment) and a knowledge layer (embeddings of internal docs/API specs). Replaces or complements smaller coding LLMs in a private ops backbone.
Data control & security
Self-hosting on your infrastructure ensures source code, terminal output, and execution logs never transit external APIs—reducing surface area for IP leakage and enabling compliance with data residency rules. No telemetry or training-data ingestion from the model itself. Note: self-hosting is an architectural choice; the model itself makes no cryptographic or audit guarantees. You remain responsible for infrastructure security, access controls, and log retention.
Hardware footprint
**Estimate**: 397B params ≈ 794 GB in float32. Practical deployments: ~100–160 GB (int8); ~50–80 GB (4-bit quantization, e.g., GPTQ/AWQ). Single-GPU feasible with 4-bit + offloading; multi-GPU (4–8× H100 80GB) recommended for production throughput.
Integration
Integrates via standard HuggingFace transformers pipeline (text-generation). Wire into CI/CD via custom Python agents (e.g., fork test runs, parse results). Supports OpenAI-compatible API wrappers (vLLM, TGI) for drop-in chat interfaces. Expects input as structured prompts (repo context, task description, terminal state). Output is raw text; use regex or LLM-as-judge to extract structured decisions (e.g., commit messages, file paths). Context length unknown—verify empirically before large-repo tasks.
When it's not the right fit
- —Context length unknown: unclear if Ornith can handle very large repos or long conversation histories; verify before multi-file reasoning tasks.
- —Real-time latency-critical ops: 397B model is compute-heavy; expect 5–30s per query depending on hardware. Not suitable for sub-second response requirements.
- —Models without evaluation transparency: benchmark tables present coding metrics (SWE-bench, Terminal-Bench), but reproduction methodology and dataset licensing not fully disclosed; use with caution in compliance-sensitive environments.
- —Smaller cost budgets: even quantized, 397B requires significant GPU investment; smaller dense models (9B, 31B variants exist) may suffice and reduce hardware cost.
Alternatives to consider
DeepSeek Coder / DeepSeek-V4
Comparable MoE architecture, strong SWE-bench scores, open weights. Trade-off: potentially better reasoning at scale, but Chinese developer (geopolitical/data-residency considerations for some orgs).
Qwen 3.5 (base, 32B or 72B)
Ornith is post-trained on Qwen 3.5; smaller, denser variants available. Lighter inference, easier to self-host, but less specialized for agentic coding tasks.
LLaMA 3.1 (405B) + custom RL fine-tuning
Fully open-weight, widely deployed. Requires your own RL pipeline to match Ornith's agentic specialization; higher setup cost but maximum customization.
Related open models
FAQ
Can I run this on a single GPU?
Yes, with aggressive quantization (4-bit) and parameter offloading to CPU/disk. Expect slower inference (10–30s per query). For production, 4–8× H100s recommended.
Is this model licensed for commercial use in my company's products?
MIT license permits commercial use, redistribution, and modification without restriction. You can embed Ornith in internal tools or derivative products. No license fees or attribution clauses beyond standard MIT compliance (preserve license text).
What happens to my code and logs when I self-host this?
All data stays in your infrastructure. The model itself does not phone home, log usage, or train on your inputs. You control access, retention, and deletion. This is an ops/compliance advantage of self-hosting vs. API-based coding agents.
How much training or fine-tuning would it take to adapt this to my codebase?
Unknown from the model card. The self-improving RL framework is mentioned but not released separately. Expect 1–2 weeks of engineering to set up a custom RL loop; data requirements (labeled code tasks, execution traces) depend on your domain.
Build Private Agentic AI for Your Engineering Ops
Ornith-1.0-397B is ready to integrate into your internal ops stack via LLM.co. We help you deploy, fine-tune, and orchestrate this model alongside your CI/CD, logging, and compliance infrastructure—keeping all code and execution context in your environment. Let's talk.