Poolside, a US AI startup, has released Laguna XS.2: an open, free model designed to run programming tasks locally, even offline. For an SME, this news isn’t about winning a technical race between AI labs; it’s more practical: useful AI is becoming more private, cheaper, more customizable and less dependent on large closed platforms. That can change how automations, internal tools and systems are built—many of which still require too much manual intervention today.
Over the past months the conversation around AI has been dominated by ever more powerful—but also more expensive and closed—models. OpenAI, Anthropic and Google compete at the high end. Meanwhile, companies like DeepSeek, Qwen and Xiaomi have pushed another direction: more open, cheaper models that are good enough for many real uses.
The new thing is that a US player, Poolside, appears with an interesting proposal: models specialized in programming and agent work. In other words, AI that not only answers questions but can plan, write code, use tools and execute steps to solve a task.
For businesses surrounded by spreadsheets, CRMs, emails, forms, calls, systems that don’t talk to each other and processes that rely on copy-and-paste, this matters.
What exactly has Poolside released
Poolside has introduced two models in the Laguna family:
| Model | What it is | Who it seems aimed at |
|---|---|---|
| Laguna M.1 | A large, proprietary model geared toward complex engineering tasks | Large companies, government, critical environments |
| Laguna XS.2 | An open model under the Apache 2.0 license, smaller and more efficient | Developers, startups, teams that want to run AI locally |
The protagonist for most is not the large model. It’s Laguna XS.2.
Why? Because Poolside publishes it under the Apache 2.0 license. In simple terms: you can use, modify and adapt it—even commercially—with very few restrictions.
It’s also designed to run locally. Not necessarily on any average laptop, mind you. We’re talking about machines with substantial memory or powerful GPUs. But the direction is clear: capable models that don’t force you to send everything to the cloud.
And that opens an important door.
Local AI: less dependence, more control
When a company uses a closed cloud model, it gets convenience. But it also accepts several dependencies:
- Dependence on the provider’s price.
- Dependence on their usage limits.
- Dependence on their availability.
- Dependence on their privacy policies.
- Dependence on the model not changing behavior overnight.
For many tasks this isn’t a problem. If you want to summarize a text or generate ideas for a campaign, an external model can be perfect.
But when we talk about more sensitive internal processes—customer data, incidents, private documentation, contracts, code, operations—the picture changes.
A model that can run locally or in a private environment allows a different architecture: more controlled, more auditable and less exposed.
This doesn’t mean all SMEs should set up their own AI server tomorrow. For most, it wouldn’t make sense. But it does mean teams building automations have more options to design secure, sustainable solutions without locking the client into a single platform.
At Studio SmartWork this fits with an approach we already use: leverage open, proven tools like n8n and well-integrated APIs to build tailored automations without creating unnecessary vendor lock-in.
What “agentic coding” means
The term sounds technical, but the idea is simple.
A normal chatbot answers. An agent tries to do.
In Poolside’s case, their models are optimized for agentic programming: they can analyze a task, review files, propose changes, write code, run tests and fix errors.
This isn’t useful only for programmers. It matters because many business automations require exactly that: connecting systems, transforming data, creating rules, detecting errors and keeping processes running.
Grounded examples:
- An agent checks why an integration between the CRM and email failed.
- Another generates a small internal tool to convert orders into invoices.
- Another adapts a flow so leads from a new source are properly tagged.
- Another detects that an automation breaks when a field is missing and proposes a fix.
Today many of these tasks still rely on a technical person. With more capable, specialized models, part of that work speeds up dramatically.
Human judgment doesn’t disappear. But the cost to build and maintain internal systems goes down.
The important point: it’s not just “another model”
Poolside claims Laguna XS.2 performs very well on real software problem-solving tests. In some benchmarks it approaches much larger models and outperforms other known models on specific programming tasks.
Should you take benchmarks with caution? Always.
Lab tests aren’t the same as the chaos of a real company: legacy databases, poorly named fields, undocumented processes, exceptions accumulated over years and decisions that depend on context.
But even so, the trend is clear: small, specialized models are improving quickly.
And that matters more than the exact ranking.
For a long time the logic was: if you want good AI, you need the biggest, most expensive and closed model. Now another alternative is emerging: smaller models trained for concrete tasks that do specific jobs very well and can be run in a more controlled way.
For SMEs, that’s often the winning pattern. You don’t need “the smartest AI in the world.” You need AI that’s good enough, reliable, integrated into your process and reasonably priced.
Privacy returns to the center
One of the most relevant parts of the news is that Laguna XS.2 can run offline. This is especially interesting for sectors where data matters a lot:
- Professional firms.
- Clinics.
- Accounting and advisory firms.
- Industrial companies.
- E-commerce with customer data.
- Sales teams with sensitive information.
- Companies with confidentiality agreements.
In these cases many automations stall over a logical question: where do my data go?
Local AI doesn’t solve every security problem, but it allows designing solutions where certain information never leaves the company environment. That’s an advantage.
It can also help where connectivity is unreliable, where there are internal compliance requirements, or where you want to reduce dependence on external services.
Again: this doesn’t mean everything must run locally. The smart choice is to pick wisely. Some tasks are perfectly fine with cloud models. Others should be kept in private environments. The key is designing the system, not chasing trends.
What could change in an SME’s automation
Most SMEs don’t have an AI problem. They have an operations problem.
Repeated tasks. Scattered information. Slow responses. Forgotten follow-ups. Processes that depend on a single person. Data copied manually between tools.
Models like Laguna XS.2 don’t solve that on their own. But they make it easier to build the missing pieces.
For example:
1. More tailored automations
Instead of making your company fit a rigid tool, you can create flows that match how you actually work.
A bot that classifies emails by your criteria. A system that enriches leads before handing them to sales. An automation that reviews incidents and routes them to the right team.
2. Lower maintenance costs
One problem with automation is processes change. The CRM changes. Fields change. Sales methods change. Teams change.
If AI helps review, adapt and test flows, maintaining automations becomes faster and cheaper.
3. More technological independence
Closed tools are convenient, but they can create cages. If your whole process depends on a single platform, migrating can be costly.
Open models and open-source tools reduce that risk. They don’t eliminate it, but they give more room to maneuver.
4. Faster creation of internal tools
Many companies need small tools that are never built because “it’s not worth it.” An internal dashboard. A proposal generator. An alert system. A connector between two apps.
With more capable programming agents, those solutions can be built faster.
At Studio SmartWork we see this constantly: sometimes a simple automation removes 3 or 4 hours of manual work every day. You don’t need to transform the entire company. You just need to fix the right bottleneck.
Note: this isn’t magic and doesn’t replace good implementation
Be clear: an open and powerful model doesn’t mean any company can download it and get value in an afternoon.
To make it work in a real business you need several things:
- A deep understanding of current processes.
- A clear definition of what to automate and what not to automate.
- Integration with existing tools.
- Tests for normal cases and edge cases.
- Error measurement.
- Ongoing maintenance as the business changes.
Technology is a piece. Implementation is the important work.
That’s why many AI initiatives stay as nice demos. They perform well in a test, but don’t survive Monday morning when 200 emails arrive, three customers call at once and the CRM has incomplete data.
The value is in turning AI into a reliable flow.
Practical takeaway for business owners
If you run a company, you don’t need to memorize the name Laguna XS.2. The important part is understanding the trend.
AI is moving in three directions that do affect your business:
- More capability: models do more complex tasks, not just text.
- More openness: alternatives that don’t depend on a single provider are appearing.
- More local or private execution: greater control over data and costs.
That means automating processes will become increasingly accessible. Not because everything is free, but because building useful solutions requires less time and infrastructure than before.
It also means advantage won’t come from just “using AI” generically. Advantage will come from applying it to specific processes before your competitors do:
- Respond to leads in under 60 seconds.
- Reduce a three-hour daily inbox to 15 minutes.
- Produce commercial proposals in 10 minutes instead of 1–2 days.
- Connect tools that today force copy-and-paste.
- Handle calls and FAQs 24/7.
That’s useful AI. Not the kind that impresses in a demo, but the kind that gives time back to the team.
Where Studio SmartWork fits
At Studio SmartWork we don’t sell packaged software. We design, build and operate custom automations for companies that want to get repetitive work off their plates.
News like Poolside’s matters to us because it expands the set of components we can use: open models, more private execution, more capable agents and less closed tools.
But our approach remains the same: first the problem, then the technology.
If an automation needs a cloud model, we use it. If a more private architecture is appropriate, we design it. If simple rules and n8n are enough, we don’t introduce AI where it’s unnecessary.
Good automation isn’t about using the newest tool. It’s about making the process work, save time and not break every few days.
Conclusion
Laguna XS.2 is another sign that open, specialized AI is maturing. It won’t change the operations of every SME overnight, but it points to a near future where businesses can have more private, better-adapted and more affordable automations.
For business owners the message is simple: you don’t need to follow every AI release. But you should start looking at internal processes with new eyes.
If a task is repetitive, information-based and follows a clear logic, it can probably be automated already. And with models like Laguna XS.2, there will increasingly be more ways to do it well—with more control and less dependence.
The AI race isn’t only about who has the biggest model. For SMEs, the important race is different: who turns these capabilities into recovered hours, faster responses and more robust operations first.