Category: Platform

OS-level isolation, need-to-know by design
When your agents handle real customer data, “we take security seriously” isn’t an answer. The architecture is.

One company, one isolated environment

On Agentura, every company runs inside its own OS-isolated environment, enforced by the Linux kernel. That means a dedicated per-company Linux user with a private 0700 home directory, a per-company private network, and every Linux capability dropped by default. Your agents live in their own walled-off slice of the system, not in a shared pool where one tenant’s process can quietly read another’s.

The point of this design is what happens in the worst case. Even if an attacker reached container-root inside one company’s environment, Unix file permissions still block them from listing — let alone reading — another company’s data, the dropped capabilities stop them mounting filesystems or escalating, and the private network gives them no path to anyone else. Crossing the boundary would take a kernel-level or Docker-daemon escape, not a misconfigured policy. Separation isn’t something you trust someone to enforce — it’s enforced by the operating system itself.

Strong separation, without the VM tax

The classic way to isolate tenants is to give each one a full virtual machine. It works, but it’s heavy: slow to start, expensive to run, and wasteful when most of that VM sits idle. Agentura draws its boundaries a different way — per-company UIDs, private networks, and dropped capabilities, all enforced by the shared host kernel — so you get hard, OS-level separation between companies at the density and speed of containers, without paying for a fleet of per-tenant virtual machines.

The strongest security boundary is the one an attacker can’t talk their way around. A dropped capability doesn’t make exceptions.

Need-to-know, by design

Isolation keeps companies apart. Need-to-know access control keeps things tidy inside your company too. Each agent only sees the data and the tools you explicitly grant it — and a connector that isn’t granted is never even registered as a tool the agent could call.

That gives you real control over your own AI workforce:
- Grant a support agent your customer conversations while withholding the billing connectors — a denied tool is refused at the call gate, not just hidden.
- A back-office agent gets the connectors it needs for its job and none of the others.
- New projects start with no connectors and no data; access is something you link, on purpose — not a default everyone inherits.
The result is a system where blast radius is small by construction. Every agent operates with the access you chose for it, so a mistake or a bad instruction is contained, not catastrophic.

Security you can reason about

Good security isn’t a long list of features — it’s a model you can actually hold in your head. Companies are isolated at the operating-system level. Agents are scoped to what you grant. Capabilities start at zero and are added deliberately. When the architecture is this explicit, you can give your customers a clear, honest answer about how their data is kept apart — because the answer is built into how the platform runs.

See how Agentura keeps your data isolated →
May 26, 2026
Free models — or bring your own (even Claude)
The model behind your agent shouldn’t be a cage. On Agentura, it’s a dropdown.

Strong open models, included

Every agent you build can run on a high-quality open model at no per-token cost. We include capable families like Qwen, GLM, Kimi and MiniMax — the kind of models that handle real support conversations and real work, not toy demos. For most agents, that’s all you need, and there’s no per-message charge to run them.

This matters because it changes the math. Instead of paying per token on every reply, included models draw on a generous monthly token allowance that comes with your plan — so you can run a whole team of agents on the same predictable bill.

Need a frontier model? Bring your own

Some jobs call for the absolute top of the line. When they do, you’re not stuck with our menu — you can bring your own provider. Plug in your own account and route an agent to a frontier model, including your own Claude subscription. Usage on a provider you bring runs on your own account, outside the included allowance.

Use an included open model where it’s good enough, and your own frontier provider where it counts. The choice stays yours, agent by agent.

One dropdown per agent

Model selection happens exactly where you’d expect: each agent’s model is chosen from a dropdown. Want your front-line support agent on a fast included model and your analysis agent on something heavier you brought yourself? Set each one independently — the change hot-reloads, with no config files and no redeploys. Pick the model that fits the job.
- Run most agents on included open models with no per-token cost, drawing on your plan’s monthly allowance.
- Point specific agents at your own frontier provider when the task demands it.
- Change your mind later — switch an agent’s model whenever you like.
No lock-in, fully accounted for

All model traffic — included or your own — routes through a metering proxy, so usage is always visible and accounted for in one place. That’s the quiet benefit of this design: flexibility on the front end, consistency on the back end. You’re never trapped with a single vendor’s pricing, and you never lose sight of what’s actually being used.

The principle is simple. Your agents, your models, no vendor lock-in.

Choose the right model for every agent →
May 25, 2026
Transparent metering & per-agent limits — no bill shock
The fastest way to lose trust in AI is an invoice you can’t explain. So we built Agentura to give you a number you can always trace.

Usage you can actually see

Every agent’s billable model call is metered at the source. Agent traffic routes through a proxy that records each call into a single usage table, which means there’s one honest source of truth for what each agent consumed — token by token, not a guess at month-end. You can look at any agent and know what it’s been doing and how many tokens it spent.

That visibility is the foundation for everything else. You can’t control what you can’t measure, and you can’t trust a number you can’t trace.

Hard ceilings, per agent

Transparency tells you what happened. A ceiling decides what’s allowed to happen. On Agentura each agent has a hard token and request limit — a real cap, not a soft suggestion. Give your high-traffic support agent room to work and keep an experimental agent on a short leash. Each one stays inside the limit set for it.

A limit you can’t enforce is just a wish. Ours is checked before the request ever leaves the building.

A circuit-breaker for runaway costs

Most bill shock comes from one thing: something loops, retries, or misbehaves and quietly burns through tokens while no one’s watching. Agentura stops that at the source with a circuit-breaker. Each agent’s token and request budget is checked before the upstream call — so when an agent hits its limit, the request is rejected before it reaches the model, spending zero tokens, not refunded after the damage is done.

That ordering is the whole point. Plenty of systems tell you what you already spent. This one stops the runaway in the first place.
- Transparent metering — every agent’s billable usage recorded through the proxy.
- Per-agent ceilings — hard token and request limits.
- Circuit-breaker — runaway loops rejected before the upstream call.
No bills you can’t explain

Put it together and you get predictability. You know what each agent is doing, you cap what each agent can consume, and you have a hard stop that fires before tokens are wasted. Running a team of AI agents stops being a leap of faith and becomes something you can plan around — every number on your usage traces back to a real call, with no end-of-month dread.

Run your agents with usage you can trace →
May 24, 2026
EU-hosted, open-source, GDPR-friendly
For a European business, where your data lives isn’t a detail. It’s the whole question.

Hosted in the EU

Agentura is EU-hosted. Your agents, your conversations and your customer data live on European infrastructure — which is exactly what you need when your customers, your contracts and your regulators all expect it. Data sovereignty isn’t an add-on you negotiate later; it’s where the platform runs from the start.

The free, included models run on that same on-host infrastructure, so for those agents the conversation content stays in Europe end to end. If you choose a third-party cloud model — or bring your own — your prompts are sent to that provider, which may sit outside the EU; you decide which models handle which work. That clarity matters for the conversations you have with your own clients, too. “Where is our data processed?” is one of the first questions any serious buyer asks, and you get a precise answer rather than a hopeful one.

GDPR-friendly, and confidential by default

Being EU-hosted is the foundation; how you treat the data on top of it is what counts. Agentura is GDPR-friendly, and the platform itself keeps your conversations confidential — it records usage counts for metering, never the words your agents and customers exchange. On the included local models that content never leaves the host at all. Use a third-party model and its handling is governed by that provider’s terms, so pick the ones whose contracts match your obligations.

Your customers’ words should work for your business — not become training data for someone else’s.

Built on an open-source core

Agentura is built on an open-source core. The tenant runtime is built from the open-source OpenClaw image, so the way the platform works isn’t a black box — and you’re not betting your operations on a single proprietary stack you can never inspect. That’s more than a nice-to-have; it’s a trust signal.
- Open-source core — transparent foundations, not a black box.
- EU-hosted — data sovereignty for European businesses.
- GDPR-friendly — built with European data rules in mind.
- Confidential by default — the platform stores usage counts, not your conversations.
Isolation at the kernel

Underneath all of it, each company runs with per-company kernel-enforced isolation. There’s no shared free-for-all: every company gets its own host user account with a locked-down 0700 home directory, its own private Docker network, and containers stripped of every Linux capability with privilege escalation blocked. It isn’t a separate virtual machine — it’s hard, operating-system-enforced boundaries between tenants, so data sovereignty isn’t just a region on a map. EU-hosted location plus per-company separation is a combination European businesses can stand behind.

Add it up and Agentura is built for the way Europe actually does business: data hosted in Europe, rules that are respected, a platform that doesn’t mine your conversations, and a foundation you can see.

Keep your data in Europe, by design →
May 23, 2026
Projects: structure your agent organisation
A pile of agents isn’t an organisation. Structure is what turns AI into something you can actually run.

A layer that mirrors how you work

Agentura organises everything through a clear hierarchy: Company → Project → Team → Agent. It’s the same shape your real business already has. A company runs projects; projects need teams; teams are made of people — or here, agents. Instead of bending your operation to fit the tool, the tool reflects how you actually operate.

That structure pays off the moment you have more than a couple of agents. You stop thinking about “all my agents” as one undifferentiated blob and start thinking in terms of the work each project owns.

One active project, in focus

At any moment, one project is active, and it scopes the things you’re working with: Connectors, Data, Chatbox and CRM. Switch into a project and the platform narrows to exactly that context — the integrations, the records and the conversations that belong to it. No wading through everything at once just to find the one thing you need.

Focus is a feature. When the active project is the only thing on screen, your team and your tools point the same direction.

Nothing goes dark when you switch

Focusing on one project doesn’t mean the others stop. Other projects keep running in the background — their agents are still answering, still working — and anything that needs you shows up as unread badges. You get the calm of a single active workspace without the anxiety of missing what’s happening elsewhere.
- Active project scopes Connectors, Data, Chatbox and CRM to the work in front of you.
- Other projects keep running, with unread badges when they need attention.
- One hierarchy — Company, Project, Team, Agent — that mirrors your real org.
Logical grouping that scales

The value here is simple but compounding: as you add agents, the structure keeps them legible. Each project is a self-contained unit of work with its own connectors, data and customer context, and your teams of agents sit neatly inside them. Growing from a handful of agents to a real AI workforce stops being chaos and starts being org design.

Organise your agents into real projects →
May 22, 2026
A built-in CRM, linked to every conversation
The best CRM is the one that’s already up to date. On Agentura, it lives where your agents and customers already are — so keeping it current takes less work.

A CRM that lives where the work happens

Agentura includes a built-in CRM, scoped to your active project. It isn’t a separate tool you bolt on and hope someone remembers to update — it sits inside the same workspace your agents and customers already use. Switch into a project and its contacts and records are right there, alongside its connectors, data and conversations.

Because the CRM is project-scoped, customer context stays organised the same way the rest of your work does. The right records show up in the right project, not in one undifferentiated contact dump.

Conversations that link themselves to the record

Here’s the part that changes things: a conversation doesn’t sit in isolation from your CRM. When a customer reaches out and shares an email address, Agentura detects it and links that conversation to their existing contact automatically — no one has to look up who’s writing in. From there your agent can work over the full ticket history and even draft a reply grounded in everything already on the record, ready for you to review and send.

A CRM only earns its keep when it’s accurate. Wiring the conversation straight onto the contact is how it stays true.

Returning customers, recognised

Because incoming conversations are matched to a contact by email, a returning customer isn’t an anonymous visitor every time — Agentura knows which record they belong to. And when an agent needs the back-story, it can search past conversations on demand and pick up the thread with the relevant history in hand. That’s the difference between a help desk that treats every message as a cold start and one that can find what came before.
- Built-in CRM scoped to the active project — no separate tool to sync.
- Auto-linked in conversation — a detected email connects the chat to its contact, with no manual lookup.
- History on demand — agents can search past conversations and draft replies grounded in the record.
Context that compounds

Put it together and your customer record keeps filling in as you work. Every inbound message, ticket and note lands against the right contact, and every future conversation can draw on that fuller picture. Instead of a database that decays the moment people stop updating it, you get a record that gets richer through the conversations your team and agents are already having.

Give your agents a CRM that stays current →
May 21, 2026