Open-Weight LLM · Private & Custom AI
Ornith-1.0-9B
A 9B coding-agent model for companies building internal agentic automation and self-hosted DevOps workflows that need tight control over data and inference.
Ornith-1.0-9B is a specialized open-weight LLM fine-tuned for agentic coding tasks (SWE-Bench, Terminal-Bench, repo navigation). It's built on Qwen 3.5 and uses RL-based self-improvement to generate both solutions and search scaffolds. For ops teams: it's a private, MIT-licensed base for automating code-related workflows—deployment scripts, bug detection, repo analysis—without sending logic to external APIs.
Model facts
Private deployment
Run Ornith-1.0-9B in your own environment
Single-GPU deployable (9B dense, ~18–36 GB VRAM depending on precision). Deploy via vLLM, Ollama, or custom inference stacks in your own environment. No external calls = data stays internal. Suitable for on-prem or VPC-isolated cloud infra. Trade-off: coding-specific tuning means narrower use than general LLMs; verify it handles your automation domain before committing.
Operational AI use cases
Automated Code Review & Incident Response
Deploy as a private agent to scan GitHub/GitLab diffs, detect anti-patterns, suggest fixes, and auto-triage security issues. Runs Terminal-Bench at 43.1% vs. Qwen3.5-9B's 21.3%—strong for scripting and shell-command generation during incident response.
Internal Repo Navigation & Knowledge Bot
NL2Repo benchmark (27.2) shows it can map natural-language queries to codebase sections. Build a private Slack/Teams bot that helps engineers navigate internal monorepos, locate deprecated APIs, or trace dependency chains—without exposing code to third parties.
DevOps Workflow Automation (IaC & Deployments)
Use as the backbone of a self-hosted agent for generating Terraform/CloudFormation templates, Dockerfile optimizations, and k8s manifests. SWE-Bench Verified (69.4%) indicates strong capability for multi-step infrastructure-as-code reasoning.
Custom AI
As a base for custom AI
Strong foundation for building a private coding-automation platform (e.g., internal code-gen service, custom linter-agent, or DevOps command assistant). MIT license permits finetuning and commercial product embedding. Context length unknown—verify it suits your code-snippet windows before productizing. Pair with RAG (private docs, internal APIs) and tool-use scaffolding to extend beyond stock capabilities.
In the operating system
Where it fits
Agent/action layer in an AI ops system. Sits between a workflow orchestrator (n8n, Temporal) and code-execution sandbox. Not a retrieval layer (no built-in RAG)—integrate with vector DBs for codebase indexing separately. Acts as the 'brain' for code reasoning; pair with tool-use frameworks (Anthropic-style tool-use or OpenAI function-calling patterns) to call deployment APIs, test runners, and internal services.
Data control & security
Self-hosting in your VPC or on-prem means code, logs, and inference outputs never cross to external servers. Useful for regulated industries (financial, healthcare, defense) handling proprietary algorithms or sensitive infra. MIT license permits private modification. Note: 'secure' depends on your deployment architecture (API exposure, log retention, access controls)—the model itself is open-weight, so no cryptographic guarantees. Review your own secrets management and inference-endpoint isolation.
Hardware footprint
**Estimate** — 9B dense parameters: - **FP32**: ~36 GB VRAM (single high-end GPU) - **FP16 / BF16**: ~18 GB VRAM (RTX 4090, A100 40GB comfortable) - **Int8 quantization**: ~9–12 GB VRAM (A6000, RTX 4080 viable) - **Int4 (GPTQ/AWQ)**: ~3–4 GB VRAM (consumer GPUs, edge) Inference speed: ~50–200 tokens/sec depending on precision and batch size. No context-length specification provided—benchmark your code-generation windows.
Integration
Export via HuggingFace transformers or convert to ONNX/TensorRT for inference servers. APIs: vLLM, TGI (Text Generation Inference), LocalAI support transformers pipeline. Integrate via REST or gRPC. Expect ~15–50ms latency per token (varies by hardware). Supports batching for multi-agent workflows. Tool-use: design JSON schemas for code-execution actions (e.g., 'run_test', 'deploy_commit'). Chain with langchain, llama-index, or custom Python orchestrators.
When it's not the right fit
- —Your automation domain is non-coding (finance, logistics, HR)—specialized tuning means weak general reasoning; use Qwen3.5-9B or Llama 3.1-8B instead.
- —You need very long context (document summarization, book-length analysis)—context window unknown; high risk.
- —Inference latency is critical at <5ms—9B models unlikely to meet that bar without exotic quantization and infra; consider distilled models or API-backed solutions.
- —Your compliance regime requires model transparency/audit—open-weight is transparent, but RL fine-tuning methodology and training data provenance require vendor documentation you'll need to request.
Alternatives to consider
Qwen3.5-9B (base)
General-purpose, broader reasoning, likely larger context window. Use if you need multi-domain automation; trade-off: not coding-specialized, so weaker on SWE-Bench tasks.
Llama 3.1-8B
Apache 2.0 licensed, strong community, good on code reasoning (via instruction tuning). Smaller footprint; less specialized than Ornith but more adaptable for hybrid workflows.
DeepSeek-Coder-6.7B
Dedicated coding model, comparable size, permissive license. Evaluate head-to-head on your SWE-Bench and Terminal-Bench proxies; may be faster due to smaller params.
FAQ
Can I run this entirely on-premise without cloud API calls?
Yes. Deploy via vLLM or TGI on your own GPU hardware or on-prem VPC. No external calls required. You control inference endpoints, logging, and data flow entirely. Compliance benefit: code and logs remain in your environment.
Is this model licensed for commercial products?
Yes, MIT license permits commercial use, modification, and redistribution. You may embed it in a product you sell or offer as a service, provided you include a copy of the MIT license. No royalty or approval required. Verify terms if using other dependencies (base Qwen 3.5 is Qwen license—review compatibility).
What's the performance gap vs. larger Ornith variants (31B, 35B, 397B)?
Trade-off table in model card shows 9B is competitive on SWE-Bench Verified (69.4 vs. 35B's 70.0), but lags on SWE-Bench Pro (42.9 vs. 44.6). For DevOps/infra tasks, the gap may be acceptable; for complex multi-repo reasoning, 31B/35B variants justify the VRAM cost. Benchmark on your use case.
Does Ornith work with LoRA / instruction-tuning for my domain?
Unknown from the model card. MIT license permits experimentation. Recommend testing QLoRA or full finetune on a sample of your target tasks (internal scripts, deployment logs) before production rollout. Expect retraining on 1–4 H100 hours for modest domain adaptation.
Build a Private Agentic Automation System
Ornith-1.0-9B is primed for self-hosted DevOps agents and code-automation workflows. LLM.co helps you deploy, integrate with your ops stack, fine-tune for your domain, and scale across your infrastructure—keeping all data and logic in-house. Ready to automate your first workflow? Let's talk.