Laguna M.1 (free)
Laguna M.1 (free) is Poolside’s flagship agentic coding language model, offered with a free access tier via API and platforms like OpenRouter.
What is Laguna M.1 (free)?
Laguna M.1 (free) is a 225B-parameter Mixture-of-Experts language model from Poolside focused on agentic coding and complex software engineering tasks. It is mainly used for autonomous or assisted code generation, editing, and debugging within terminal agents and cloud dev environments, with long-context reasoning and tool-calling support for sophisticated coding workflows. A free tier of this proprietary model is exposed via OpenAI-compatible APIs and third-party routing platforms for experimentation and integration into existing tools. Laguna M.1 belongs to Poolside’s Laguna model family and serves as the larger companion to the open-weight Laguna XS.2 model.
Providers
Different companies host the same model. OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto (highest tool-calling accuracy).
| Provider | Input | Output | Cache read /M | Latency | Throughput | Uptime |
|---|---|---|---|---|---|---|
| Poolside (Laguna M.1 free tier) | $0.00 | $0.00 | — | ~220ms | ~25 tps | ~99.0% |
| Poolside (Laguna M.1 paid) | ~$0.30 | ~$0.30 | — | ~180ms | ~40 tps | ~99.5% |
| OpenRouter (Laguna-equivalent model) | ~$0.40 | ~$0.40 | — | ~260ms | ~30 tps | ~99.9% |
| Together AI (Laguna-equivalent model) | ~$0.35 | ~$0.35 | — | ~250ms | ~35 tps | ~99.9% |
Try this model
Test Laguna M.1 (free) right here — free to start.
Suggestions for your first prompt
Code snippet
Call the model through the OpenAI-compatible API.
from openai import OpenAI
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://inference.example.com/v1"
)
response = client.chat.completions.create(
model="poolside/laguna-m-1-free",
messages=[
{
"role": "user",
"content": "Describe this image in one sentence."
}
],
)
print(response.to_json())
{
"model": "poolside/laguna-m-1-free",
"messages": [
{
"role": "user",
"content": "Describe this image in one sentence."
}
]
}
5 Core Capabilities
-
Agentic Coding
Specialized in complex, long-horizon software engineering tasks, autonomously editing, refactoring, and extending codebases across multiple files.
-
Tool Calling
Invokes external tools and APIs from natural language instructions to run tests, interact with systems, and orchestrate workflows.
-
Code Reasoning
Performs strong logical and structural reasoning over code, enabling reliable bug fixing, feature implementation, and test creation.
-
Long-Context Handling
Processes very large text contexts, maintaining coherence over long coding sessions, logs, and multi-file repositories within a single prompt.
-
Multilingual Text
Understands and generates text in multiple languages, supporting international codebases, comments, and documentation across diverse locales.
6 Most Valuable Use Cases
- Autonomous Code Generation
- Complex Bug Fixing
- Repository-wide Refactoring
- API Integration Assistance
- Long-Context Code Review
- Agentic Dev Workflow Monitoring
Why Build on LLM.API?
One unified API. Every major model. Built-in reliability, cost control, and observability.
-
Unified AI Routing
Dynamically route each request to the optimal model across providers based on latency, cost, or quality—no client changes required as your stack evolves.
One endpoint, any model -
Cost-Aware Orchestration
Automatically shift traffic to cheaper equivalents, apply smart downscaling, and cap spend per workspace so you can experiment without surprise bills.
Cut cost, not coverage -
Automatic Fallback Flows
Define failover policies once and let LLM.API transparently retry on alternate models or providers when timeouts, errors, or quota limits hit.
Resilience by default -
End-to-End Observability
Get request tracing, latency breakdowns, cost per call, and model-level success metrics in one place to debug faster and tune routing with real data.
See every token -
Task-Level Abstractions
Describe tasks like chat, extraction, or classification and let LLM.API pick the right model and parameters—no more provider-specific boilerplate everywhere.
Code to tasks, not models -
High-Throughput Batch
Streamline large workloads with optimized batching, concurrency controls, and rate-limit aware scheduling to maximize throughput while staying within provider quotas.
Scale jobs, stay safe
When to Use — When NOT to Use
Use it if...
- You need a free, general-purpose LLM for everyday coding, writing, and brainstorming.
- You need to prototype AI features quickly without incurring usage-based API costs.
- Your use case involves moderate-length chats or prompts that fit within typical limits.
- Your use case involves non-sensitive experimentation, internal tools, or hackathon-style projects.
- You need a backup or overflow model when paid primary providers hit rate limits.
- Your use case involves lightweight code review, bug-spotting, or simple refactoring tasks.
- You need language assistance for drafting emails, support replies, or marketing copy.
Avoid if...
- You need guaranteed enterprise-grade SLAs, uptime commitments, and formal support channels.
- Your workload requires processing highly sensitive, regulated, or confidential production data.
- You need state-of-the-art performance on complex reasoning, advanced math, or long tool chains.
- You need extremely long context windows for large documents, transcripts, or multi-file codebases.
- Your workload requires strict latency guarantees for real-time user-facing or streaming applications.
- You need fine-tuning, custom model weights, or deep configurability beyond generic chat completion.
- Your workload requires certified compliance (e.g., HIPAA, PCI) and detailed data governance controls.
Frequently Asked Questions
-
What is Laguna M.1 (free)?
Laguna M.1 (free) is a Poolside language model available via LLM.API, suited for general-purpose text generation and coding assistance without usage fees.
-
What is Laguna M.1 (free) best suited for?
Laguna M.1 (free) is best for iterative coding, debugging, and explaining code, plus general chat and lightweight reasoning tasks.
-
How is Laguna M.1 (free) priced when used through LLM.API?
Laguna M.1 (free) is exposed as a zero-cost tier on LLM.API, charging no per-token fees but possibly subject to fair-use limits.
-
What context window does Laguna M.1 (free) support?
Laguna M.1 (free) supports a context window of up to 16K tokens for combined prompt and completion.
-
How fast is Laguna M.1 (free) in terms of latency and throughput?
Laguna M.1 (free) is optimized for low latency interactive use, typically streaming first tokens within a second under normal load.
-
Which modalities does Laguna M.1 (free) support?
Laguna M.1 (free) is text-only, supporting text input and text output, without native image, audio, or video understanding.
-
How do I call Laguna M.1 (free) via the LLM.API gateway?
You select provider "Poolside" and model "Laguna M.1 (free)" in your LLM.API request, passing messages in the standard Chat Completions schema.
-
How does Laguna M.1 (free) compare to similar mid-size open models?
Laguna M.1 (free) targets performance comparable to strong mid-range open models while emphasizing low friction access and stable, predictable behavior.
-
What are the main limitations of Laguna M.1 (free)?
Laguna M.1 (free) can hallucinate facts, lacks real-time browsing tools, and may underperform larger frontier models on complex reasoning or domain-expert tasks.
-
Does Laguna M.1 (free) support function calling or tools via LLM.API?
Laguna M.1 (free) can be used with LLM.API’s tool or function-calling abstractions when you define tools in the request and handle structured outputs.
COMPARE
Competitive Models
-
Qwen3.5 397B A17B
Qwen3.5 397B A17B is a large-scale language model from Qwen with roughly 397 billion parameters, designed for advanced reasoning and multilingual understanding. It targets high-end inference scenarios where strong general capabilities and model depth are required.
-
GLM 5
GLM 5 is Z.ai’s fifth-generation large language model, a large open-source Mixture-of-Experts foundation model focused on advanced reasoning and long-horizon agent workflows. It is notable for its frontier-scale parameter count (around 744–745B total, ~44B active) and very long context window of about 200K tokens.
-
Nova 2 Lite
Nova 2 Lite is an Amazon foundational language model variant designed to provide efficient, general-purpose AI capabilities with reduced computational footprint. It is intended for everyday workloads where cost-effectiveness and responsiveness are prioritized over maximum scale.
Get one key to every model
Swap your API key. Keep your code.