Build
Connect & operate
Design & teams
Start hereScope a build in one callBring a spec, a wireframe, or a paragraph. You leave with an architecture, a timeline, and a number.Book a scoping call
AI software
LLM & data systems
Vibe coding
Ready to ship?Put AI where the work isAgents, RAG, and private LLMs wired into the systems your team already uses — not a chatbot bolted to a homepage.Discuss an AI project
Domain firstWe learn your workflow before we model itRegulated, operational, or high-volume — the constraints belong in the schema, not in a training doc.Talk about your domain
Plan smarterEstimate before you commitCost ranges, scope templates, and the questions we ask in discovery — free, no form.Open the cost calculator
Real conversationsTalk with a technical leadNo SDR, no discovery gauntlet. The person on the call is the one who scopes the build.Book a call
Open-Source LLM · ByteDance-Seed

Seed-OSS-36B-Instruct

Seed-OSS-36B-Instruct is a 36-billion-parameter open-source language model from ByteDance's Seed Team, released under Apache-2.0. It supports 512K context length natively and is optimized for reasoning, agent tasks, and long-context scenarios. The model achieves competitive performance on standard benchmarks (MMLU-Pro: 82.7%, MATH: 81.7% base version) despite being trained on only 12T tokens. No gating required; available for immediate download.

Source: HuggingFace — huggingface.co/ByteDance-Seed/Seed-OSS-36B-Instruct
36.2B
Parameters
apache-2.0
License (OSI-approved)
Unknown
Context (tokens)
37.5k
Downloads (30d)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

FieldValue
DeveloperByteDance-Seed
Parameters36.2B
Context windowUnknown
Licenseapache-2.0 — OSI-approved
Modality / tasktext-generation
Gated on HuggingFaceNo
Downloads37.5k
Likes503
Last updated2025-08-26
SourceByteDance-Seed/Seed-OSS-36B-Instruct

What Seed-OSS-36B-Instruct is

Causal language model with GQA attention, SwiGLU activation, RMSNorm, and RoPE positional encoding. Architecture: 64 layers, 80 QKV heads with 8 KV heads, 5120 hidden size, 128 head size, 155K vocabulary. Trained with up to 512K context natively. Two variants available: with and without synthetic instruction data in pretraining. Last update: 2025-08-26.

Quickstart

Run Seed-OSS-36B-Instruct locally

Load the open weights with 🤗 Transformers and generate — the same model, self-hosted.

quickstart.pypython
from transformers import pipelinepipe = pipeline("text-generation", model="ByteDance-Seed/Seed-OSS-36B-Instruct")out = pipe("Explain retrieval-augmented generation in one sentence.",           max_new_tokens=128)print(out[0]["generated_text"])

Swap in vLLM or Ollama for production-grade serving. DEV.co can stand up the inference stack.

Deployment

How you'd run it

A typical self-hosted path — open weights, an inference server, your application.

DEV.co builds each layer — from GPU infrastructure to the application.

Best use cases

Long-context document analysis and RAG

Native 512K context enables processing of full documents, codebases, or conversation histories without truncation. Suitable for retrieval-augmented generation systems requiring extended context windows.

Agentic AI and tool-orchestration workflows

Model card explicitly highlights agentic capabilities. Well-suited for autonomous agents that call APIs, execute tools, and resolve multi-step problems with reasoning.

Math and reasoning-heavy applications

Strong performance on GSM8K (90.8%), MATH (81.7%), and BBH (87.7%) benchmarks. Appropriate for tutoring systems, symbolic reasoning, and technical problem-solving.

Running & fine-tuning it

ESTIMATE: 36B parameters in bfloat16 = ~72 GB VRAM. Full precision (float32) ≈ 144 GB. Feasible on single high-end GPU (H100 80GB would require quantization or pipeline parallelism) or multi-GPU setup. For inference optimization: quantization (int8/int4) could reduce to 18–36 GB. Serving frameworks like vLLM support distributed inference. Exact throughput metrics not provided; requires testing.

Model card does not explicitly document LoRA/QLoRA feasibility, adapters, or fine-tuning guidelines. Standard HuggingFace transformers library compatibility assumed (architecture uses standard components: RoPE, GQA, SwiGLU). LoRA fine-tuning likely feasible but requires empirical validation. Two base variants (with/without synthetic data) available for research-oriented fine-tuning, offering flexibility for downstream task adaptation.

When to avoid it — and what to weigh

  • Production systems requiring guaranteed latency SLAs — 36B parameter model will require substantial compute. Inference latency and throughput depend heavily on hardware and serving framework. No benchmarked serving metrics provided.
  • Strict real-time knowledge cutoff or fact-heavy QA — SimpleQA performance is low (9.7% on instruct variant). Model may not be optimal for applications requiring up-to-date factual accuracy without retrieval augmentation.
  • Resource-constrained edge or mobile deployment — 36B parameters require significant GPU/TPU memory. Quantization or distillation would be necessary for edge devices; no pre-quantized variants mentioned.
  • Closed commercial environments with strict provenance requirements — Synthetic instruction data used in training may not meet some enterprise audit requirements. Model card offers non-synthetic variant (Seed-OSS-36B-Base-woSyn) but instruct variant uses synthetic data.

License & commercial use

Apache-2.0 license. Permissive open-source license (OSI-approved) granting rights to use, modify, and distribute subject to license notice and disclaimer retention.

Apache-2.0 is a permissive OSI license that explicitly permits commercial use, modification, and distribution, provided license conditions are met (retain license notices, state material changes, include disclaimer). No additional commercial restrictions in model card. However, verify with legal counsel whether synthetic instruction data in pretraining triggers any third-party licensing obligations not disclosed here. Non-synthetic base variant (Seed-OSS-36B-Base-woSyn) available if provenance sensitivity exists.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

SignalAssessment
MaintenanceActive
DocumentationAdequate
License clarityClear
Deployment complexityModerate
DEV.co fitStrong
Assessment confidenceHigh
Security considerations

No formal security audit, penetration testing, or adversarial robustness evaluation mentioned. Standard LLM risks apply: model poisoning via synthetic data, prompt injection, information leakage in long contexts, and misuse for automated harmful content generation. Synthetic instruction data used in base model introduces potential alignment inconsistencies compared to human-authored data. No stated content filtering or safety fine-tuning. Recommend: (1) pre-deployment adversarial testing, (2) input validation/filtering in production, (3) monitoring for jailbreak attempts, (4) data governance for sensitive use cases (healthcare, finance).

Alternatives to consider

Qwen2.5-32B or Qwen3-32B

Similar parameter count and competitive MMLU-Pro performance (58.5–81.8 depending on variant). Qwen ecosystem offers more serving tooling and community examples. Seed-OSS-36B outperforms on MATH (81.7 vs. 63.5) but trails on SimpleQA (9.7 vs. 6.1–8.6).

Gemma3-27B

27B alternative with comparable reasoning capability (BBH, math benchmarks). Smaller footprint reduces hardware requirements. Lower MMLU-Pro (67.5) and coding performance but may suit edge-constrained scenarios.

OAI-OSS-20B (Open-Source GPT-4-class models, if available)

Smaller footprint (20B) with competitive instruct-mode MMLU-Pro (76.2%) and superior AIME performance (92.7%). Trade-off: smaller model size vs. Seed-OSS-36B's long-context strength (512K).

Software development agency

Ship Seed-OSS-36B-Instruct with senior software developers

Start with a benchmark on your hardware, evaluate on your domain tasks, and consider quantization for cost optimization. For agent-heavy or long-context workloads, test against Qwen and OAI-OSS alternatives. Consult our team for production-scale serving architecture.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

Seed-OSS-36B-Instruct FAQ

Can I use this model commercially?
Yes. Apache-2.0 is a permissive open-source license that explicitly allows commercial use, modification, and distribution. You must retain license notices and include a disclaimer. Consult legal counsel if synthetic instruction data in pretraining raises third-party IP concerns for your specific use case.
What GPU do I need to run this model?
Approximately 72 GB VRAM for bfloat16 inference on a single GPU (e.g., H100 80GB, A100 80GB). For smaller GPUs, use quantization (int8 ≈18–36 GB) or multi-GPU distribution. Exact latency and throughput depend on hardware, batch size, and serving framework; benchmark before production deployment.
How does Seed-OSS-36B compare to closed models like GPT-4?
On open benchmarks, Seed-OSS-36B-Instruct (82.7% MMLU-Pro, 91.7% AIME) is competitive with open-source and mid-tier closed models (Qwen3, OAI-OSS-20B) but trails flagship proprietary models (Seed1.6-Thinking: 86.6% MMLU-Pro). Long-context (512K) and agentic capabilities are notable strengths. Task-specific evaluation required.
Are there pre-trained vs. instruction-tuned variants?
Yes. ByteDance releases Seed-OSS-36B-Base (with synthetic instruction data), Seed-OSS-36B-Base-woSyn (without synthetic data), and Seed-OSS-36B-Instruct. Choose the non-synthetic base variant if synthetic data concerns exist; instruct variant is recommended for direct deployment.

Custom software development, end to end

DEV.co has shipped open-source llms software across regulated and high-growth industries. Our software development services and AI development services cover the work that follows a decision to adopt Seed-OSS-36B-Instruct.

Ready to Deploy Seed-OSS-36B?

Start with a benchmark on your hardware, evaluate on your domain tasks, and consider quantization for cost optimization. For agent-heavy or long-context workloads, test against Qwen and OAI-OSS alternatives. Consult our team for production-scale serving architecture.