Powered by Poolside
Laguna M.1 (free)
- Instruction Following
Laguna M.1 (free) is Poolside’s flagship agentic coding language model, offered with a free access tier via API and platforms like OpenRouter. It is a large Mixture-of-Experts model optimized for complex software engineering tasks and long-context coding workflows.
About the model
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.
Model capabilities
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.
Use cases
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
Transparent pricing
Cost Comparison
LLM API offers the lowest cost and latency for Laguna M.1–class models.
| Provider | Region | Latency | Throughput | Uptime | Input ($/1M) | Output ($/1M) | Context |
|---|---|---|---|---|---|---|---|
| LLM API BEST | Global | 110ms | 85 tps | 99.99% | $0.20 | $0.20 | 128K |
| Poolside (Laguna M.1 free tier) | Global | ~220ms | ~25 tps | ~99.0% | $0.00 | $0.00 | ~32K |
| Poolside (Laguna M.1 paid) | Global | ~180ms | ~40 tps | ~99.5% | ~$0.30 | ~$0.30 | ~64K |
| OpenRouter (Laguna-equivalent model) | Global | ~260ms | ~30 tps | ~99.9% | ~$0.40 | ~$0.40 | ~128K |
| Together AI (Laguna-equivalent model) | US East | ~250ms | ~35 tps | ~99.9% | ~$0.35 | ~$0.35 | ~128K |
Performance benchmarks
Technical Specifications
| Metric | Laguna M.1 (free) | GPT-4o mini | Claude 3.5 Haiku |
|---|---|---|---|
| Avg Latency | ~800ms | ~600ms | ~700ms |
| Context Window | 128K | 128K | 200K |
| Input Price ($/1M) | ~$0.00 | ~$0.15 | ~$0.25 |
| Output Price ($/1M) | ~$0.00 | ~$0.60 | ~$1.25 |
| Max Output Tokens | 4K | 4K | 4K |
| Throughput | ~30 tps | ~50 tps | ~40 tps |
| Uptime | 99.0% | 99.9% | 99.9% |
30-day usage via LLM API
- 3.8B
- Prompt tokens processed (last 30 days)
- 26M
- Completion tokens generated (last 30 days)
- 1.1M
- API requests served (last 30 days)
- 210K
- Unique users (last 30 days)
Architecture & Integration
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
Decision guide
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.
FAQ
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.