Poolside launched Laguna S 2.1 on July 21, 2026. The model was developed for agentic coding and long-horizon software engineering. SuperQode 0.2.35 adds local support for Laguna S 2.1 through DwarfStar and llama.cpp, with both engines using the same downloaded GGUF.
The implementation connects Laguna to SuperQode's provider layer, local server lifecycle, model policy, reasoning handling, and terminal interface. It also establishes a reproducible model download through the standard Hugging Face cache. SuperQode does not store a user-specific model directory.
A model developed for agentic coding
Laguna S 2.1 is a 118B parameter Mixture-of-Experts model with approximately 8B parameters activated per token. It has 48 transformer layers, 256 routed experts, one shared expert, and top-10 expert routing. Its attention layout combines 12 global attention layers with 36 sliding-window attention layers.
The distinction between total and active parameters is relevant to local inference. The model retains the capacity of a large expert system while routing each token through a smaller part of the network. Quantization reduces the memory required to store the weights, which makes the official Q4_K_M GGUF practical on a 128 GB Apple Silicon Mac.
Poolside designed Laguna S 2.1 for tasks that require sustained interaction with a development environment. The model supports a context window of up to 1,048,576 tokens and can reason before and between tool calls. Thinking can be controlled for each request. Poolside recommends retaining prior reasoning content during agentic sessions because later tool turns can depend on that state.
These capabilities address requirements that are not measured by short code-completion prompts. Repository work requires the model to inspect files, understand existing conventions, call tools, process tool results, edit related files, run tests, and revise an implementation when verification fails.
Poolside reports scores of 70.2 percent on Terminal-Bench 2.1, 78.5 percent on SWE-bench Multilingual, and 59.4 percent on the public SWE-Bench Pro dataset. Poolside also published the evaluation trajectories used for the release. The trajectories provide evidence about the sequence of tool calls, reasoning, changes, and verification behind the reported results.
The launch post includes an example in which Laguna S 2.1 optimized Poolside's own agent harness over several hours. The model measured each attempt and retained changes that produced an improvement. Poolside reports a final speed improvement of 5.2 percent and approximately 70 percent lower memory allocation. This example evaluates the model inside an iterative engineering loop rather than as an isolated chat model.
Poolside describes post-training across terminal and software engineering environments that include real repository history, merged pull requests, injected bugs, deleted-file reconstruction, dependency installation, and test execution. The training process also used multiple agent harnesses to develop behavior that transfers across different coding-agent environments.
Local inference through DwarfStar and llama.cpp
The official Laguna S 2.1 GGUF repository includes the Q4_K_M file used for the SuperQode integration. The file is approximately 68 GB. On a 128 GB Mac, the remaining unified memory is used by macOS, the inference runtime, KV cache, SuperQode, and development tools.
SuperQode starts with a 32K context for this local configuration. Laguna supports substantially more context, but increasing the active context also increases runtime memory requirements. The appropriate value depends on the inference engine, prompt size, and available memory.
DwarfStar provides a model-specific inference path through its laguna-s2.1 branch. The branch was updated for the revised Laguna GGUF files, including the Q4_K_M configuration with Q8 projections and smaller routed experts. Antirez reported approximately 60 tokens per second for generation and 550 tokens per second for prefill in his test configuration. Performance varies by hardware, context, and runtime settings.
DwarfStar exposes OpenAI-compatible chat completions, an OpenAI Responses endpoint, and an Anthropic-style messages endpoint. These interfaces carry streamed output, tool calls, and reasoning content across multi-turn coding sessions.
llama.cpp provides the general GGUF server path. Poolside maintains a Laguna branch of its llama.cpp fork, and upstream support is tracked through llama.cpp pull request 25165. A current Laguna-capable build is required. An older llama.cpp build used during this work rejected the --reasoning-preserve argument, which confirmed that the runtime version must be checked before starting the managed server.
What changed in SuperQode 0.2.35
SuperQode now recognizes laguna-s-2.1 as a portable local model alias. The resolver searches the standard Hugging Face cache for Poolside's official laguna-s-2.1-Q4_K_M.gguf. The same resolver is used by DwarfStar and llama.cpp, so the model is downloaded once and reused without copying the file.
The resolver honors HF_HOME and HF_HUB_CACHE when the Hugging Face cache has been relocated. SUPERQODE_LAGUNA_GGUF can point to a GGUF stored outside the cache, and an explicit GGUF path can still be supplied on the command line. None of these paths is hardcoded in the TUI.
Laguna was added to the local model matrix, local recommendations, model pack data, harness model policy, system prompt guidance, and provider registry. The LiteLLM gateway recognizes the Laguna family and preserves reasoning content required by continued tool execution.
The DwarfStar integration now presents three named API behaviors for the same loaded GGUF. Poolside Laguna S 2.1 leaves thinking under request control. Poolside Laguna S 2.1 Chat disables thinking. Poolside Laguna S 2.1 Reasoner enables thinking. These entries are behavior variants exposed by the DwarfStar API, not separate model files.
The TUI previously displayed those API aliases as indistinguishable duplicates. SuperQode 0.2.35 assigns each variant a clear name. The llama.cpp connection flow was also changed so discovered models appear in a dedicated model picker instead of being appended to the local provider list.
The managed DwarfStar launch performs an incremental build when --build is supplied, even if a ds4-server binary already exists. This prevents an older binary from being treated as Laguna-compatible solely because the executable is present.
The managed llama.cpp launch resolves the same cached model and applies the Laguna server settings. The integration enables the Jinja chat template and reasoning preservation for a compatible llama.cpp build.
Download Laguna S 2.1 once
Download the official Q4_K_M GGUF with the Hugging Face CLI. The command uses Hugging Face's standard cache and prints the resolved snapshot path when the download completes.
hf download \
poolside/Laguna-S-2.1-GGUF \
laguna-s-2.1-Q4_K_M.ggufDo not add --local-dir for the standard-cache workflow. The completed cache entry can be verified before either inference engine is started.
hf cache verify poolside/Laguna-S-2.1-GGUFRun Laguna with DwarfStar
Use a DwarfStar checkout on the laguna-s2.1 branch or a compatible ds4-server binary. SuperQode resolves the cached GGUF, starts the managed server, checks the live provider, and can run a completion through the same provider path used by the coding harness.
superqode local serve ds4 \
--model laguna-s-2.1 \
--ctx 32768 \
--build
superqode providers doctor ds4 --live
superqode providers smoke ds4 \
--model laguna-s-2.1 \
--run \
--prompt "Inspect the current repository and summarize its architecture."Start SuperQode inside the repository that the model should inspect. Enter :connect local, choose DwarfStar 4, and select the required Laguna behavior. The reasoner variant is intended for agentic coding tasks that need thinking before and between tool calls.
cd /path/to/project
superqode
# Inside the TUI
:connect localRun the same GGUF with llama.cpp
Stop DwarfStar before loading the model with llama.cpp. Confirm that the installed llama.cpp build supports Laguna, then start the managed server with the same laguna-s-2.1 alias.
superqode local stop ds4
llama-server --version
superqode local serve llama.cpp \
--model laguna-s-2.1 \
--ctx 32768
superqode local serversIn the TUI, enter :connect local, choose llama.cpp Server, and select laguna-s-2.1 from the dedicated model screen. Only one inference engine should load the model at a time on a 128 GB Mac.
Validation completed for the release
The official Q4_K_M artifact was downloaded into the standard Hugging Face cache during this work. SuperQode resolved the cached file without a user-specific model path. DwarfStar loaded the updated GGUF, and its model endpoint was discovered through the SuperQode TUI.
The initial DwarfStar model list exposed three API aliases with the same visible name. The TUI was changed to display the request-controlled, chat, and reasoner variants separately. The llama.cpp model list was moved to its own selection screen after the original interface displayed provider selection and model discovery on the same page.
Automated coverage was added for standard-cache resolution, direct GGUF overrides, DwarfStar launch behavior, stale binary handling, the three DwarfStar variants, the llama.cpp selection screen, managed server arguments, Laguna model policy, reasoning preservation, LiteLLM gateway behavior, and local stack recommendations.
The final release validation completed with 2,418 passing tests and 38 skipped tests. Ruff lint, Ruff formatting, public documentation style, the strict MkDocs build, HarnessSpec doctor checks, release metadata checks, and package builds also passed.
Local agentic coding with SuperQode
Laguna S 2.1 provides an open-weight model developed for terminal use, repository work, reasoning, and long-running tool interaction. DwarfStar and llama.cpp provide local inference on Apple Silicon. SuperQode connects that inference to a coding-agent harness with project context, tools, permissions, model policy, provider diagnostics, and verification.
SuperQode 0.2.35 makes this configuration reproducible. Users download one official GGUF into the standard Hugging Face cache, select an inference engine, and connect the model through the same terminal workflow used by other SuperQode providers.