Poolside Laguna M1 Free Acces: Access Status

Poolside Laguna M1 free access is no longer a dependable public API option: the OpenRouter free variant was marked as ending on July 28, 2026, and the current Poolside model list no longer includes a free M1 entry. You can still obtain Laguna M1’s weights under Apache 2.0, but that means you must supply and pay for the inference hardware or hosting rather than receiving no-cost hosted usage.

The search query’s duplicated name and misspelled “acces” usually point to an older free-route announcement. The important distinction is between free hosted inference, free-to-download weights, and a free API key. They are not the same thing, and confusing them is how an apparently free 225B model becomes an unexpectedly expensive weekend.

Is Poolside Laguna M1 free in 2026?

As of August 6, 2026, do not plan a project around free hosted access to Laguna M1. Poolside announced on April 28 that both Laguna M1 and Laguna XS.2 would be free through its API and OpenRouter for a limited time. That qualification mattered: the historical OpenRouter listing for poolside/laguna-m.1:free explicitly says it was “Going away July 28, 2026.”

The current catalog evidence points the same direction. OpenRouter’s current Poolside provider page lists free variants for the newer Laguna S 2.1 and Laguna XS 2.1, while M1 appears only as Laguna M1, without a free variant or published token price on that listing. Poolside’s own current getting-started page likewise advertises the newer S 2.1 and XS 2.1 models as free in Preview, not M1.

That does not prove nobody can obtain a promotional exception, a private allocation, or a temporary provider route. It does mean there is no longer a public, documented M1 free tier that an engineer should treat as available capacity. If a UI, blog post, or cached model page still shows :free, check its end date and try a real request before building an integration around it.

What does free access to Laguna M1 mean?

There are three separate offers people collapse into one phrase:

• Free hosted inference: A provider runs the model and does not charge per token. This was the temporary M1 route. It is the part that has expired publicly.
• Free weights: You may download, modify, and use the model checkpoint under its license. Laguna M1’s Hugging Face model card identifies Apache 2.0 licensing, including commercial and non-commercial use.
• A free API key or client: Signing up may cost nothing, and a tool may be free to install, while actual inference remains metered, capacity-limited, or available only for particular models. A free key is not a promise of free M1 tokens.

This distinction is especially important for M1 because it is not a small local model. Poolside describes Laguna M1 as a mixture-of-experts model with 225 billion total parameters and 23 billion activated parameters per token. The model card also says loading the BF16 checkpoint through Transformers needs substantial multi-GPU memory; it recommends vLLM or SGLang for single-node serving and provides FP8 and NVFP4 checkpoints. Sparse activation reduces inference work relative to a 225B dense model, but it does not eliminate memory, GPU, storage, networking, or operations cost.

How can I use Poolside Laguna M1 now?

Choose a route based on what you are trying to learn. For a quick evaluation, first check whether a provider exposes the non-free M1 model in its live catalog and pricing page, then set a hard token budget. For local or controlled deployment, download the official weights and run a compatible server. For production, treat the choice as an infrastructure and data-governance decision, not a model-download decision.

Can I self-host Laguna M1 for free?

You can self-host the software and weights without paying Poolside a license fee, subject to Apache 2.0 and Poolside’s acceptable-use terms. But self-hosting is not free in the economic sense. A full checkpoint needs serious storage and multi-GPU memory; a quantized checkpoint lowers the hardware threshold but still requires capable accelerators for a usable coding-agent experience.

Poolside documents upstream support for vLLM, SGLang, Transformers, and TensorRT-LLM. The most practical setup for an engineering team is usually an OpenAI-compatible server behind an internal gateway: applications send standard chat-completions-style requests, while the gateway handles authentication, spend limits, logging policy, routing, and retries. Preserve the model’s reasoning content across tool-call turns when the serving stack exposes it; Poolside says M1 is designed for interleaved reasoning between tool calls and works best when that reasoning context is retained.

# Illustrative vLLM shape from Poolside's model documentation
vllm serve \
  --model poolside/Laguna-M.1 \
  --tool-call-parser poolside_v1 \
  --reasoning-parser poolside_v1 \
  --enable-auto-tool-choice \
  --served-model-name laguna

Run this only after validating the current vLLM release, driver stack, GPU topology, checkpoint variant, and model-specific parser support. “It loaded” is not enough for an agentic coding workload: verify tool-call formatting, long-context behavior, streaming, cancellation, concurrent requests, and what your observability system records.

Should I use Laguna M1 for coding agents?

Laguna M1 is aimed squarely at agentic coding and long-horizon software work. Its published model card reports a 262,144-token context window, native reasoning support, tool calling, and benchmark results including 74.6% on SWE-bench Verified and 45.8% on Terminal-Bench 2.0. Those are useful signals that the model was evaluated in the kind of environment developers care about, but they are not a deployment guarantee.

The benchmark setup deserves the same attention as the score. Poolside says its M1 evaluations used its agent harness, up to 500 steps, thinking enabled, and sandboxed environments; it also notes patches to some task images and verifiers. Your repository may have different languages, test reliability, permissions, CI latency, package registries, security boundaries, and definition of “done.” Evaluate it against a small suite of your own bugs and feature tasks before committing to a hosting strategy.

What should I use instead of the expired M1 free route?

If your goal is simply to experiment with a current free Poolside coding model, inspect the free tiers for Laguna S 2.1 or Laguna XS 2.1 instead. They are the models Poolside’s current getting-started page and OpenRouter’s current Poolside catalog explicitly present as free. They are different models, licenses, sizes, and performance profiles, so do not substitute one in benchmark notes or production configurations while calling it M1.

If your goal is to evaluate M1 specifically, obtain current paid or approved access if it is offered, or self-host the official weights. Keep the experiment narrow: choose representative tasks, cap output and reasoning budgets, record pass rate and wall-clock time, inspect each diff, and calculate the cost of failed agent loops. That produces a useful engineering answer; chasing a stale free slug does not.

Try provider-flexible coding workflows with Cline

For engineers comparing hosted models, self-hosted endpoints, and temporary free routes, Cline is an open-source AI coding agent offered as a VS Code extension and CLI. Its site says the open-source product is free for individual developers, with inference paid on a usage basis; you can bring your own API keys or use Cline’s provider.

That is relevant here because an expired Laguna M1 free route should not force a wholesale tool change. Cline supports provider flexibility, including OpenRouter, so you can keep an agent workflow while testing whatever current endpoint, budget, and model access your team has chosen. It does not make M1 inference free—but it can make switching away from stale access paths substantially less disruptive.