DEV Community: Martin

Neleto Console Is Live — and the Free Tier Is Open

Martin — Tue, 30 Jun 2026 08:00:00 +0000

Neleto Console is live at console.neleto.io, and the free tier is open for self-serve registration. Go there, create an account, pick the Free plan, and a few moments later you have your own Neleto instance running — no sales call, no card, no waiting on me.

That last part took longer to earn than I'd like to admit. The whole loop — provision a server, install the Neleto stack, issue a license, send your credentials — now runs untouched by human hands. If you've followed these build-in-public posts, you'll know that was the open seam I kept refusing to paper over on a pricing page. It's closed.

What you get on Free

One user, 1 GB of storage, and a real Neleto site — not a demo, not a sandbox that resets overnight. It runs on shared infrastructure, so there's no backup and the limits are real, but everything that makes Neleto Neleto is there: the integrated rendering and the page builder. Build your site by hand in the builder, or point Claude, Cursor, or Windsurf at the native MCP server and have it write pages for you by prompt. Both work. The AI angle is a big part of why I built this — but you don't need it to get value on day one.

When you outgrow Free, Starter is €24/mo, Team €59/mo, and Business €149/mo. Upgrading moves you off the shared box onto your own dedicated server — more room, more performance, and backups — without you having to migrate anything by hand.

Why give it away

The free tier exists for one reason: so you can actually experience Neleto before deciding anything. No demo, no sales deck, no expense approval — just a real site you can build on and judge for yourself. That's the only way I'd want to be sold a tool, so it's how we're selling this one.

And every instance, free ones included, runs on EU infrastructure by default. Your data sits under European data-protection law, not a US cloud provider's terms. For a lot of the people we talk to — agencies, public-sector teams — that's not a footnote, it's the whole reason they call.

The honest status

This is day one. The free tier is live and the self-serve flow works end to end — that's the hard part, and it's real. But the shared-tier limits are conservative on purpose while I watch how a hundred instances behave on one box under real traffic, and a few other paid-plan features are still on the bench. If you hit a rough edge in the first weeks, you're seeing a young system in public, which is exactly where I want it.

So go to console.neleto.io, sign up for free, and put it through its paces. If something's confusing, slow, or broken, I want to hear about it. We did this in the open so the first people through the door could shape what it becomes — and the door's open now.

— Martin

MCP Server Explained: The Deep Dive

Martin — Tue, 23 Jun 2026 08:00:00 +0000

The Model Context Protocol (MCP) has quickly become one of the most important developments in the AI tooling space since its introduction by Anthropic in late 2024. While many developers have heard of MCP, fewer understand what an MCP Server actually is, how it works under the hood, and why native implementation in applications like CMS platforms matters significantly.

This deep dive breaks it down clearly.

What is an MCP Server?

An MCP Server is the server-side implementation of the Model Context Protocol. It acts as a standardized interface that allows AI models and agents to discover, connect to, and interact with external tools, data sources, and applications in a secure, structured way.

Think of it as a universal adapter. Instead of every AI application building custom integrations for every tool (databases, CRMs, CMSs, file systems, etc.), the MCP Server provides a common language and protocol that any MCP-compatible client can use.

Key responsibilities of an MCP Server:

Resource discovery: Exposing what data and capabilities are available
Tool registration: Defining functions/actions the AI can call
Context provision: Supplying relevant, up-to-date information to the model
Permission enforcement: Ensuring the AI only does what it’s allowed to do
Secure communication: Handling authentication and controlled access

MCP Architecture: Client vs Server

MCP follows a client-server model:

MCP Client: Usually lives inside the AI application (e.g., Claude Desktop, Cursor, Windsurf, or custom agents). It initiates connections and makes requests.
MCP Server: Lives inside the target application (your CMS, database, internal tool, etc.). It responds to requests and executes actions.

This separation is powerful. It means:

AI tools don’t need to know the internal details of every system they connect to.
Application developers only need to implement the MCP Server once to become compatible with the entire ecosystem of MCP clients.

The protocol handles discovery, capability negotiation, and structured requests/responses, making integrations much more reliable than traditional custom API work.

Why “Native” MCP Server Implementation Matters

Not all MCP support is created equal. There’s a meaningful difference between:

Bolt-on / Proxy MCP servers — Built as middleware or separate services that sit in front of your application.
Native MCP servers — Deeply integrated into the core of the application, with direct access to internal data models, permissions, and business logic.

Benefits of native implementation:

Better security: The server understands your existing permission model natively instead of trying to replicate it.
Stronger consistency: Actions taken by AI agents follow the same rules and audit trails as human users.
Deeper integration: The AI can work with rich internal concepts (content types, relationships, workflows) rather than just raw data.
Lower latency & complexity: No extra network hops or translation layers.
Future-proofing: As the protocol evolves, native implementations can adapt more cleanly.

This is why platforms that ship with a native MCP server (like Neleto) offer a meaningfully better experience than those that rely on external proxies or custom integrations.

Security and Permissions Model

One of the biggest concerns with giving AI agents access to production systems is control. MCP was designed with this in mind.

A well-implemented MCP Server should:

Respect existing role-based access control (RBAC)
Allow granular scoping of what resources and actions are exposed
Maintain full audit logs of agent activity
Support human-in-the-loop approval workflows where needed
Never bypass application-level business rules

When done correctly, an AI agent using MCP should have the same (or more restricted) capabilities as a human user with the same role — nothing more.

This is a major advantage over older approaches like giving AI systems broad API keys or database access.

Real-World Use Cases in Content Management

While MCP has broad applications, it shines particularly well in content systems:

1. AI-assisted content creation

An agent can research, draft, and directly create or update blog posts, landing pages, or product descriptions inside the CMS.

2. Automated content operations

Agents can bulk-update metadata, reorganize content structures, translate content, or apply taxonomies consistently.

3. Intelligent content maintenance

AI can identify outdated content, suggest improvements, or keep related pieces in sync.

4. Developer + AI collaboration

While a developer builds new features or components, an AI agent can simultaneously update the corresponding content entries without manual handoff.

The key is that these actions happen inside the CMS with proper permissions and workflows — not as disconnected generations that someone has to copy-paste later.

How Neleto Implements the MCP Server

Neleto was designed with AI collaboration as a core principle from the beginning. Its native MCP server is deeply integrated into the platform’s architecture.

This means:

AI agents connect directly to Neleto’s data layer and permission system
They can create, read, update, and manage all standard content types (pages, blog posts, events, etc.)
Actions respect the same role-based permissions configured for human users
Changes are fully auditable through normal platform mechanisms
No additional infrastructure or middleware is required

Because the implementation is native, agents can work with Neleto’s concepts (layouts, components, translations, redirects) in a way that feels natural rather than fighting against a generic API layer.

This positions Neleto as one of the most AI-ready content platforms available today — not through bolted-on features, but through fundamental architecture.

The Bigger Picture: Why This Matters

We are moving from AI as a tool that generates text to AI as a collaborator that can take meaningful actions inside the systems we use every day.

For this transition to be safe and useful at scale, we need standardized, secure interfaces. MCP is rapidly becoming that standard.

Applications that implement native MCP servers will have a significant advantage:

They become part of the growing AI agent ecosystem
They reduce friction between development and content work
They future-proof their platform as agentic workflows become mainstream

For developers and agencies, this translates to faster workflows, less manual busywork, and the ability to offer clients more powerful capabilities without increasing operational complexity.

Getting Started with MCP in Neleto

If you want to experience a native MCP server in action:

Create a Neleto project (free plan available)
Connect an MCP-compatible client (such as Claude or Cursor with MCP support)
Grant the appropriate permissions
Start collaborating with AI agents directly on your content

The experience of having an AI that can actually do work inside your CMS — rather than just suggesting text — is qualitatively different.

Conclusion

An MCP Server is more than just another integration. It represents a new contract between applications and AI agents — one built on standardization, security, and native understanding of the host system.

Platforms that treat MCP as a core architectural concern (rather than an afterthought) will define the next generation of AI-augmented tools.

Neleto’s native MCP server implementation reflects this philosophy: AI should be a first-class participant in content workflows, not a disconnected generator that creates more work for humans.

The future of content management isn’t just faster tools. It’s collaborative systems where humans and intelligent agents work together seamlessly — and MCP is one of the key protocols making that future possible.

Neleto vs Contentful: Which CMS Should You Choose in 2026?

Martin — Tue, 16 Jun 2026 10:52:10 +0000

Choosing the right CMS has never been more important — or more confusing. The market is full of options, from traditional monolithic platforms to modern headless solutions. Two names that often come up are Contentful, the established enterprise headless CMS, and Neleto, the newer performance-focused, AI-native alternative.

Both are capable platforms. But they serve noticeably different needs.

This article breaks down the real differences so you can decide which one actually fits your team, budget, and goals.

Quick Comparison Overview

Starting Price

Neleto: Free / €24/mo
Contentful: Free / ~$300/mo
🏆 Winner: Neleto

Performance

Neleto: Rust backend (very fast)
Contentful: Good (depends on frontend + CDN)
🏆 Winner: Neleto

AI Integration

Neleto: Native MCP server
Contentful: AI features available, no native MCP
🏆 Winner: Neleto

Editor Experience

Neleto: Clean, intuitive admin
Contentful: Good but can feel developer-oriented
🏆 Winner: Neleto

Developer Control

Neleto: Full HTML + plugin API
Contentful: Excellent API & modeling
🏆 Winner: Tie (different strengths)

EU / GDPR Hosting

Neleto: Strong native EU option (Germany)
Contentful: Available but more complex
🏆 Winner: Neleto

Frontend Requirements

Neleto: Optional (built-in rendering)
Contentful: Required (headless)
🏆 Winner: Neleto

Best For

Neleto: Agencies, freelancers, mid-market, AI workflows
Contentful: Large enterprises, complex omnichannel
🏆 Winner: Depends

Total Cost of Ownership

Neleto: Predictable and low
Contentful: Can grow expensive quickly
🏆 Winner: Neleto

1. Pricing & Total Cost of Ownership

This is one of the clearest differences.

Contentful follows a usage-based model on top of base plans. While there is a free tier and a Lite plan starting around $300/month, costs can escalate quickly with API calls, bandwidth, and additional spaces. Many mid-sized teams report spending thousands per month once they scale.

Neleto offers transparent, predictable pricing:

Free plan for personal projects and testing
Starter from €24/month
Team from €59/month

There are no surprise usage bills for normal website operations, and you're not penalized for growing traffic in the same way.

Verdict: If budget predictability and lower total cost matter to you (especially for client work or growing businesses), Neleto has a significant advantage.

2. Performance

Neleto was built from the ground up in Rust, which gives it a substantial performance edge. Pages load faster out of the box, which directly impacts SEO, Core Web Vitals, and user experience.

Contentful is a mature platform with a strong global CDN. However, because it is purely headless, your actual site speed depends heavily on how you build the frontend and how you query the API. Many teams end up fighting performance issues that stem from architecture rather than the CMS itself.

Verdict: Neleto wins on raw speed and simplicity of achieving fast websites.

3. AI Capabilities (The New Differentiator)

This is where the gap is growing fastest in 2026.

Neleto includes a native MCP (Model Context Protocol) server. This allows AI agents (Claude, Cursor, Windsurf, etc.) to directly read from and write to your content — creating blog posts, updating pages, managing assets — while respecting your existing permissions and workflows.

Contentful has been adding AI capabilities, but it does not currently offer a native MCP server experience. Integrations tend to be more custom or one-way.

Concrete example: With Neleto + MCP, a developer can ask Claude to "write a new case study based on our latest project and publish it under the right category with the correct featured image." The agent can do this directly in the CMS.

This level of deep, native AI integration is still rare among traditional headless CMS platforms.

Verdict: If you want to work with AI agents instead of just generating text in a separate tool, Neleto is currently ahead.

4. Developer Experience vs Editor Experience

Contentful excels when you have strong development resources and need sophisticated content modeling. Its API-first approach and GraphQL support are excellent for complex, omnichannel projects.

However, many teams report that the editing experience can feel secondary to the developer experience. Non-technical users sometimes struggle or require developer support for certain tasks.

Neleto was explicitly designed with both sides in mind:

Developers get full control over HTML, layouts, a plugin API, and direct database-like access when needed.
Editors and clients get a clean, modern admin interface that requires almost no training.

It also includes built-in rendering, so you're not forced to build a separate frontend application for every project.

Verdict: Neleto offers a better balance for most agencies and teams that serve non-technical clients.

5. Hosting, Compliance & Data Residency

For European companies or anyone serving EU users, this has become a serious consideration.

Neleto gives you a clear choice at signup, including EU/Germany hosting powered by Hetzner. This makes GDPR compliance and data sovereignty significantly more straightforward.

Contentful operates globally with data centers in multiple regions. While EU options exist, the company is US-based, and compliance often requires more configuration and legal review.

Verdict: Neleto is the simpler and more transparent choice for EU-focused teams.

When Contentful Makes Sense

Contentful remains a strong choice if you:

Are a large enterprise with highly complex, multi-brand content models
Need deep omnichannel delivery across many digital properties
Already have heavy investment in a specific frontend stack and composable architecture
Have a large budget and dedicated development team
Value the maturity and extensive marketplace of a long-established platform

When Neleto Makes More Sense

Neleto is usually the better fit when you:

Want fast websites without fighting performance
Need predictable, affordable pricing (especially for client work)
Want native AI agent capabilities today (via MCP)
Serve European clients or need strong GDPR/EU data residency
Value a clean experience for both developers and non-technical editors
Don't want to be forced into a full headless + frontend framework setup
Are a freelancer, agency, or mid-sized business that wants modern capabilities without enterprise complexity

Final Verdict

Contentful is a powerful, battle-tested platform that continues to serve large organizations well. It's not going away.

However, for a growing number of developers, agencies, and businesses in 2026, Neleto offers a more modern, faster, more affordable, and AI-native alternative — especially if you value simplicity, performance, and European compliance.

The best CMS is the one that gets out of your way and lets you deliver great websites efficiently. For many teams today, that CMS is Neleto.

Ready to compare them yourself?

Try Neleto for free and see how it feels for your next project. If you're currently on Contentful and curious about migrating, we also have a WordPress importer (and are happy to discuss Contentful migrations too).

Bots Just Out-Numbered Us: What the Agentic Web Means for Your CMS

Martin — Tue, 09 Jun 2026 07:00:00 +0000

It finally happened, and it happened early.

According to Cloudflare Radar data — flagged by SemiAnalysis and confirmed by Cloudflare CEO Matthew Prince — automated traffic has surpassed human traffic on the open web for the first time in history. Bots and AI agents now account for roughly 57.5% of HTTP requests to HTML pages, with humans down to 42.5%.

The headline number is striking on its own. What makes it a genuine inflection point is when it arrived and what caused it. Prince had publicly predicted this crossover wouldn't happen until the end of 2027, and it showed up roughly 18 months ahead of schedule. The thing that pulled it forward wasn't the search crawlers and scrapers we've lived with for two decades. It was agentic AI — autonomous agents browsing, comparing, and acting on behalf of real people.

The web has quietly become an environment where machines do most of the reading, while we keep building it for the people who now make up the smaller half.

Why This Is Important
For twenty-five years, every website on the internet rested on one quiet assumption: a human will look at this. We optimized for human eyes — layouts, hero images, hover states, cookie banners, the whole ritual. The entire stack, from page-builders to analytics, assumes a person on the other end.

That assumption is now wrong more often than it's right.

Here's what's actually changing, and why it matters for anyone who runs a website:

One human now generates dozens of page visits through agents. When a person asks an AI agent to "find me the best mirrorless camera under €1,500 and book the cheapest one in stock," that single intent can fan out into thousands of page requests across hundreds of sites. The person never opened a browser; their agent opened hundreds. Your traffic graph is increasingly a record of machines reading your content.

Agents read differently than people do. A human will tolerate a slow, cluttered, JavaScript-heavy page because they want the thing badly enough to wait. An agent has no such patience. It wants structured, fast, machine-readable content, and when a site is slow or hostile to automated access, it simply moves on to a competitor that's easier to read. Being legible to agents is turning into a ranking and revenue question, not a technical curiosity.

The traffic that matters is shifting from impressions to actions. The old web rewarded getting in front of eyeballs. The agentic web rewards being the source an agent trusts and actually uses to complete a task. When an agent can reliably read your product data, your availability, your documentation — and ideally write back to it — you're in the workflow. When it can't, you're invisible, however beautiful the page looks to a human.

And this is accelerating. AI-driven traffic grew roughly 8× faster than human traffic across 2025. A milestone that landed 18 months early marks the beginning of a steep curve, not a one-off spike.

So the question every site owner, agency, and developer now has to answer is uncomfortably simple: is my content built for the audience that's actually showing up? For most sites, the honest answer is no — they're still built for the 42.5%.

Why Neleto Is the Best Thing You Can Do About It
Most teams will respond to this news the way teams usually do: by bolting something on. An AI plugin here, a scraping policy there, maybe a hastily written llms.txt. That approach treats agentic traffic as an edge case to be managed after the fact.

Neleto was built on the opposite assumption — that agents are a primary audience, not an exception.

It's a CMS written in Rust with a native Model Context Protocol (MCP) server, as far as we know the only CMS with one built in from the ground up rather than glued on later. That single architectural decision happens to be exactly what the agentic web demands.

Agents can read and write your content, safely. Most "AI integrations" let a model read a page and nothing more. Neleto's MCP server lets AI agents — Claude Code, Cursor, Windsurf, anything that speaks MCP — securely read and update your live content, following the same roles and permissions a human editor would. Instead of scraping a rendered page and guessing at its meaning, the agent works with your content through a structured, permissioned interface designed for it. In a web where agents now outnumber people, your CMS speaks their language by default.

Speed is a feature when your readers are machines. Agents are relentless: they hit thousands of pages and they don't wait around. Neleto's Rust backend runs 10–50× more efficiently than typical PHP or Node.js stacks, so it stays fast and cheap to operate even under the heavy automated load that now makes up the majority of the internet. Fast pages get read, used, and ranked; slow ones get abandoned by humans and skipped by agents alike.

Structured content beats rendered guesswork. Neleto stores content as clean, typed resources — pages, blog posts, events, files, components, translations — with integrated rendering, so there's no fragile second stack for an agent to misread. That structure is what lets an agent use your data confidently instead of hallucinating around it.

You stay sovereign while you do it. The agentic shift doesn't suspend GDPR. Neleto offers DSGVO-compliant multi-region hosting (DE/EU, US, Asia), so opening your content to agents never means handing your data to someone else's cloud jurisdiction. Your content becomes agent-ready and remains yours.

And it costs a fraction of the alternatives. Neleto starts at €19/month and runs 5–7× cheaper than Contentful or Storyblok, while shipping the one thing they don't: a native MCP server. Future-proofing your content for the agentic web shouldn't require an enterprise contract.

The Cloudflare data is a warning shot for everyone still building exclusively for human eyeballs. The web's largest audience is now machines acting for people, and that audience is growing eight times faster than the old one. You can keep patching around that reality, or you can run your content on a system that was designed for it from day one.

As of this week's numbers, the agentic web is already here — and already the larger half of the internet. Neleto is how you publish for it.

Fast websites. Easy content. AI native.
Built for the 57.5%, before everyone else noticed.

Why EU Hosting Compliance Matters for Your Website

Martin — Mon, 01 Jun 2026 09:53:45 +0000

If you run a website that serves European users — or if you’re based in the EU yourself — hosting location is no longer just a technical detail. It has become a strategic and legal consideration.

In 2026, questions around data residency, GDPR compliance, and digital sovereignty are front and center for businesses of all sizes. Choosing where your website and its data live can affect everything from legal risk to user trust and even search engine performance.

The core issue: Where does your data actually live?

When you choose a hosting provider or CMS, your content, user data, images, and analytics often get stored on servers in a specific country or region. This matters because different jurisdictions have different laws regarding data access, privacy, and government requests.

Key concerns include:

GDPR compliance: The EU’s strict data protection regulation requires that personal data of EU citizens be handled with strong safeguards. Transferring data outside the EU/EEA can trigger additional legal requirements (such as Standard Contractual Clauses).
Schrems II and data transfers: Following court rulings, simply relying on old mechanisms for transferring data to the US became more complicated. Many organizations now prefer to keep data within the EU to reduce legal complexity.
Data sovereignty: Some companies and public sector organizations want (or are required) to ensure their data is stored and processed under EU jurisdiction.
Performance and latency: Hosting closer to your users generally means faster load times — which also helps SEO and user experience.

For many European businesses, especially those handling any form of personal data (even something as simple as contact forms or newsletter signups), EU-based hosting has become the safer, simpler default.

Why traditional hosting often falls short

Many popular CMS platforms and hosting providers are headquartered outside Europe. While they may offer data centers in the EU, the company’s legal jurisdiction, data processing agreements, and potential access by foreign authorities can still create uncertainty.

Common pain points include:

Unclear or complex data processing agreements
Difficulty proving full GDPR compliance to clients or auditors
Unexpected changes in terms or pricing
Limited transparency about where data is actually processed and backed up

For agencies and freelancers building sites for European clients, these issues often become recurring headaches during sales, onboarding, and ongoing maintenance.

How Neleto approaches EU hosting compliance

At Neleto, we built EU hosting compliance into the foundation of the platform — not as an add-on.

Here’s what that looks like in practice:

Server location choice at signup: You can select EU/Germany as your hosting region. Your data is stored on servers operated by Hetzner Online GmbH in Germany — a well-established, privacy-focused European provider.
GDPR-first design: When you choose EU hosting, your content and data stay within the EU/EEA, significantly simplifying your compliance story.
Transparent infrastructure: We’re clear about where your data lives and who operates the underlying infrastructure.
No hidden data flows: Neleto is designed so that choosing EU hosting means your primary data residency is in Europe.
Portability: Your content belongs to you. If you ever decide to leave, you can export everything — no lock-in, no drama.

This approach is especially valuable for:

German and EU-based agencies working with local clients
Companies in regulated industries
Organizations that need to demonstrate strong data protection practices to customers or partners
Anyone who simply prefers keeping European data in Europe

Beyond compliance: The business benefits

Choosing proper EU hosting isn’t just about avoiding fines. It also brings practical advantages:

Faster performance for European visitors
Stronger trust signals with privacy-conscious customers
Simpler sales conversations when pitching to EU clients
Future-proofing against evolving regulations
Peace of mind knowing your infrastructure decisions align with European values around data protection

In an era where privacy is becoming a competitive differentiator, being able to clearly communicate “Your data stays in the EU” is a meaningful advantage.

Making the right choice for your projects

Not every project needs EU hosting. If your audience is primarily outside Europe and you have no EU users or data, other regions might make more sense for latency or cost reasons.

However, for the growing number of websites that do serve European audiences — or are built by European teams — having a clean, transparent EU hosting option is increasingly important.

Neleto gives you that choice without forcing you into expensive enterprise plans or complex setups. EU hosting is available across our plans, including the free tier for testing.

Final thought

Website infrastructure decisions have legal and ethical dimensions now. Choosing a platform that makes EU compliance straightforward isn’t just responsible — it’s good business.

If you’re building or managing websites for European clients (or want to), having hosting you can confidently stand behind is one less thing to worry about.

Neleto was designed with this reality in mind.

What is the Model Context Protocol (MCP)?

Martin — Tue, 26 May 2026 06:00:00 +0000

If you’ve been following the rapid evolution of AI tools in 2025 and 2026, you’ve probably heard the term MCP more and more often. But what exactly is the Model Context Protocol, and why is it becoming such a big deal for developers and content teams?

In short: MCP is the emerging universal standard that lets AI agents securely and intelligently connect to external tools, data sources, and applications.

Think of it as “USB-C for AI.”

The problem MCP solves
Before MCP, connecting AI models (like Claude, GPT, or specialized coding agents) to real-world systems was messy and fragmented. Every integration was custom-built. Want your AI to read from a database, update a CMS, or trigger a workflow? You had to write brittle, one-off code for each tool.

This created several painful problems:

Security risks from ad-hoc integrations
High development effort for every new connection
Inconsistent behavior across different AI tools
Difficulty giving AI agents reliable, up-to-date context
As AI agents became more powerful and started moving from “chatbots that answer questions” to “agents that do things,” the need for a standardized, secure communication layer became obvious.

What is MCP exactly?
The Model Context Protocol (MCP) is an open standard (originally introduced by Anthropic in late 2024) that defines how AI applications and agents can discover, connect to, and interact with external resources in a structured, secure way.

It provides a universal interface for:

Reading and writing data
Calling tools and functions
Accessing contextual information
Maintaining proper permissions and auditability
Instead of building custom integrations for every AI client, developers can now implement an MCP server once. Any MCP-compatible AI agent can then connect to it using a standardized protocol.

This dramatically simplifies things for both sides:

AI tool makers get a reliable way to connect to external systems.
Application developers (like CMS builders) only need to implement the protocol once to become “AI-agent ready.”
Why MCP matters for content management
Content is one of the most valuable and frequently updated assets in any organization. Being able to let trusted AI agents safely create, update, translate, or organize content opens up powerful new workflows:

AI coding assistants that can directly update website copy while you build features
Automated content updates based on data from other systems
Smarter content suggestions and bulk operations with human oversight
Reduced manual busywork for editors and marketers
However, this only works safely and reliably if the CMS exposes a proper, permission-aware interface. That’s exactly what a native MCP server provides.

Neleto’s approach to MCP
At Neleto, we believe AI should be a first-class citizen in content workflows — not an afterthought. That’s why we built native MCP server support directly into the platform.

This means:

AI tools like Claude, Cursor, and Windsurf can connect directly to your Neleto instance
They respect the same role-based permissions you’ve already configured
Changes are auditable and follow normal content workflows
You don’t need custom middleware or fragile API glue
With Neleto’s native MCP server, you can go further in practice. For example, Claude can not only create a new blog post but also upload and set a featured image, apply categories and tags, and follow your normal publishing or review workflow — all while staying strictly within the role-based permissions you’ve already configured.

We didn’t bolt MCP on later. We designed Neleto with AI agents in mind from the beginning, because we believe the future of content management is collaborative between humans and intelligent agents.

The bigger picture
MCP is still relatively new, but adoption is growing quickly across development tools, databases, and now content platforms. It represents a fundamental shift in how we think about AI — moving from isolated models that only know what they were trained on, to agents that can safely act on live, permissioned data in the systems you already use.

For developers and agencies, supporting MCP is quickly becoming a competitive advantage. It future-proofs your stack and lets you offer clients more powerful, AI-augmented workflows without increasing complexity.

Ready to explore MCP in action?
If you’re curious about what AI-native content management actually feels like, Neleto gives you a clean, production-ready way to experience it today.

You can start for free and connect your favorite AI coding tools directly to your content. No custom integration work required.

The age of AI agents that can meaningfully help manage websites isn’t coming — it’s already here. MCP is the standard making it practical and safe.

Why Neleto Exists

Martin — Tue, 19 May 2026 07:00:00 +0000

every time. And yet, the tools we rely on to manage websites often feel like they’re stuck in the previous decade.

That tension is exactly why Neleto exists.

The friction we kept running into

As a digitalization partner working with mid-sized companies, we saw the same patterns again and again. Traditional CMS platforms were slow, bloated, and increasingly painful to maintain. Page speed suffered, security required constant vigilance, and every new feature seemed to demand another plugin. Clients loved the end result of a custom site but hated the editing experience — or worse, they accidentally broke things.

Headless and “modern” alternatives solved some problems but created others. They were powerful for developers, yet they often pushed complexity onto clients or required expensive frontend frameworks and ongoing specialist work. Pricing frequently scaled with seats or traffic in ways that punished growing businesses. And data residency? For European companies, that was rarely a first-class concern.

Then AI changed everything.

Tools like Cursor, Claude, and Windsurf started letting developers move dramatically faster. But the content layer — the actual website content that real businesses live and die by — remained disconnected from these new workflows. AI could help write code or generate text, but it couldn’t safely and natively update the live site without fragile custom integrations.

We didn’t want to keep patching around these limitations. We wanted to remove them.

What we decided to build

Neleto was born from a simple conviction: the best CMS should feel invisible to clients and empowering to developers — while being ready for the AI-native future that’s already here.

That conviction led to several non-negotiable decisions:

Performance as a foundation, not a feature. We built the backend in Rust. The result is websites that are dramatically faster than traditional PHP or Node.js solutions — often 10-50× quicker in real-world scenarios. Faster sites rank better, convert better, and cost less to run. For agencies and freelancers delivering client work, that speed advantage compounds every single day.
Two worlds, one system. Developers get full control: direct HTML access, a clean plugin API, and complete freedom to build exactly what they need. Non-technical editors and clients get a genuinely pleasant admin interface where they can manage pages, blog posts, events, translations, and files without training or fear of breaking the site. Role-based permissions keep everything safe and organized.
AI that actually belongs in a CMS. Neleto includes a native MCP (Model Context Protocol) server — the only one we’re aware of built into a CMS from the ground up. This means AI agents can securely read and write content directly, following the same permissions and workflows humans use. It’s not a bolted-on chatbot or a future roadmap item. It’s there today, ready for the way developers and teams are already working.
European pragmatism. We host in regions you choose, with strong GDPR compliance when you select EU/Germany servers. Your data stays where you want it. Pricing is transparent and predictable. There’s no vendor lock-in — export your content whenever you like. And migration from WordPress is built in, because we know many great sites still live there.

Built by people who ship websites every day

Neleto isn’t a theoretical product designed in a vacuum. It grew out of real client work at Triple-A Soft. We kept feeling the same friction points and eventually decided the best way to solve them for our clients (and ourselves) was to build the tool we actually wanted to use.

We made it affordable enough for freelancers and small agencies while powerful enough for teams. We included the content types and features most sites need out of the box so you spend less time configuring and more time delivering value. And we designed it to get better as AI capabilities advance, rather than having to be retrofitted later.

The future we’re building toward

Neleto exists because we believe the next era of the web belongs to teams that can move fast without sacrificing control, performance, or simplicity. Developers should leverage AI as a true collaborator. Editors should feel confident managing their own content. Businesses should own their data and their speed.

That’s the CMS we wanted. So we built it.

If you’ve ever felt the gap between how fast you can develop and how painful it is to hand a site over to a client…

If you’ve ever wished your content tools kept pace with your AI-assisted workflow…

If you care about performance, compliance, and not getting locked into expensive or bloated platforms…

…then Neleto was built for you.

We’re just getting started. Try it for free, explore the documentation, or reach out if you’d like to talk about how it fits your workflow. We’re building Neleto in public with real users, and we’d love to have you along for the ride.

Fast websites. Easy content. AI native.

That’s not just our tagline. It’s why we exist.
visit neleto.io