Llama 3.1 (8B, 70B, 405B)

Generates coherent text across extended contexts up to 128,000 tokens using a transformer-based architecture optimized for long-range dependencies. All three model variants (8B, 70B, 405B) maintain the same 128K context window, enabling multi-document summarization, long-form content creation, and extended conversational threads without context truncation. The model processes the full context window in a single forward pass, allowing it to maintain semantic coherence across documents, code files, or conversation histories that would exceed typical 4K-8K limits.

Generates and translates text across multiple languages using a single unified transformer model trained on multilingual corpora. The 8B and 70B variants explicitly support multilingual capabilities, allowing zero-shot translation and cross-lingual reasoning without language-specific fine-tuning. The model handles code-switching, maintains semantic meaning across language boundaries, and can generate content in non-English languages with comparable quality to English outputs.

Integrates seamlessly with Ollama-native applications including Claude Code, Codex, OpenCode, OpenClaw, and Hermes Agent, enabling developers to use Llama 3.1 as the inference backend for specialized tools. These applications provide domain-specific UIs and workflows (code generation, agent orchestration, etc.) while delegating inference to Ollama's runtime. Developers can switch between Llama 3.1 variants or other Ollama-compatible models without changing application code.

Offers three parameter sizes (8B, 70B, 405B) with documented performance tiers, enabling developers to choose models based on latency/quality trade-offs. The 8B variant prioritizes speed and efficiency (4.9GB disk, ~8GB VRAM), the 70B balances speed and quality (43GB disk, ~40GB VRAM), and the 405B maximizes quality and reasoning (243GB disk, ~200GB VRAM). All three variants share the same 128K context window and API interface, allowing developers to swap models without code changes.

Invokes external tools and functions by generating structured function calls in a schema-based format, enabling the model to decide when and how to use external APIs, databases, or system commands. The model receives a schema definition of available tools, reasons about which tool to call based on user intent, and generates properly formatted function calls with arguments. This capability integrates with Ollama's REST API and supports streaming tool calls, allowing agentic workflows where the model orchestrates multiple tool invocations to solve complex tasks.

Generates syntactically correct code and completes partial code snippets across 40+ programming languages using transformer-based code understanding. The model was trained on diverse code corpora and can generate functions, classes, algorithms, and full programs from natural language descriptions or partial implementations. It supports code-in-context scenarios where the model analyzes surrounding code to generate contextually appropriate completions, and can generate code in languages from Python and JavaScript to Rust, Go, and domain-specific languages.

Performs multi-step reasoning and generates intermediate reasoning steps (chain-of-thought) to solve complex problems including math, logic puzzles, and multi-hop reasoning tasks. The model explicitly generates its reasoning process before arriving at conclusions, enabling transparency into how it solved a problem and improving accuracy on tasks requiring multiple reasoning steps. This capability is particularly strong in the 405B variant, which Meta claims achieves 'state-of-the-art' reasoning performance.

Executes model inference entirely on local hardware using the Ollama runtime, which provides a unified interface across CLI, REST API, and language SDKs (Python, JavaScript). The Ollama runtime handles model loading, quantization management, GPU acceleration (NVIDIA, Metal on macOS), and memory optimization. Developers can invoke the model via simple CLI commands (`ollama run llama3.1`), HTTP POST requests to `localhost:11434/api/chat`, or language-specific libraries without managing model weights, CUDA setup, or inference optimization.

Executes model inference on Ollama's managed cloud infrastructure with three pricing tiers (Free, Pro $20/mo, Max $100/mo) that control concurrent model instances and usage allowances. The cloud service routes requests to GPU-accelerated infrastructure (primarily US-based, with routing to Europe/Singapore for global demand) and charges based on GPU compute time rather than tokens. Developers authenticate with an Ollama account and make HTTP requests to Ollama's cloud API, which handles load balancing, auto-scaling, and model serving without managing infrastructure.

Generates structured outputs (JSON, YAML, XML) that conform to a specified schema, enabling reliable extraction of data from unstructured text. The model receives a schema definition (e.g., JSON schema) and generates outputs that match the schema structure, with field types, required fields, and constraints enforced. This capability integrates with Ollama's API and enables deterministic parsing without post-processing or regex-based extraction.

Generates text incrementally and streams tokens to the client in real-time as they are produced, enabling low-latency user-facing applications where users see text appearing character-by-character. The Ollama REST API supports streaming responses via HTTP chunked transfer encoding, allowing clients to display partial results immediately rather than waiting for full completion. This is particularly valuable for chat interfaces, content generation, and long-form text where users benefit from seeing progress.

Runs multiple Llama 3.1 model variants (8B, 70B, 405B) concurrently on Ollama cloud infrastructure, with concurrency limits determined by subscription tier. The Free tier allows 1 concurrent model, Pro tier allows 3, and Max tier allows 10 simultaneous model instances. This enables A/B testing different model sizes, running ensemble inference, or serving multiple users with different model preferences without managing separate infrastructure.