Author: The Agentura Team

Give your agent a personality
A generic chatbot sounds like a generic chatbot. The agents your customers actually trust sound like someone — and that someone is yours to define.

Every agent has a soul

On Agentura, each agent carries its own personality profile in a SOUL.md file: its role, its tone, and exactly how it talks to your customers. A friendly front-desk greeter and a precise, no-nonsense technical specialist are the same engine wearing two very different faces — and you decide which one shows up.

This is the difference between a tool that answers questions and a teammate that represents your brand. The personality isn’t decoration; it shapes how every reply lands.

Shape it in plain language

You don’t write code to do this. During setup you describe the agent the way you’d brief a new hire: who it is, what it handles, how warm or formal it should be, what it should never say. That description becomes the agent’s character, and you can refine it whenever the role evolves.

Tell it who to be in plain words, and it stays in character — sale or complaint, first message or hundredth.

Security is never optional

Personality is flexible. Safety is not. No matter how you shape an agent’s tone, its security guidance is always-on — the baseline rules that keep it from being talked into doing something it shouldn’t stay in place underneath every profile you write. You get full creative control over voice without trading away the guardrails.

Consistent on every channel

An agent that’s warm on your website but robotic over email isn’t really one agent. With Agentura, the personality you define travels with the agent across every channel it works on. Customers meet the same character wherever they reach you, which is exactly what makes it feel like a real member of the team rather than a script that changes with the wiring behind it.
- One profile, defined once — in language anyone on your team can write.
- One consistent voice — the same across every conversation and channel.
- One non-negotiable — security stays on, always.
Give your agent a personality →
June 1, 2026
Upload your docs: an instant knowledge base
An agent that guesses is a liability. An agent that looks it up is an employee. The difference is a knowledge base.

Upload it, and it’s ready

Drop in your files, paste your URLs, add your documents — and they become instantly available to your agent. Product manuals, policies, price lists, internal guides: whatever your team would normally have to memorize or dig for, your agent can pull from on demand the moment you’ve added it.

There’s no lengthy training step and no rigid template. If it’s in your knowledge base, your agent can use it to answer.

It reads the source, it doesn’t improvise

Under the hood, Agentura keeps your uploaded documents out of the agent’s always-on context — so they never bloat the conversation or get half-remembered. Instead, every file is text-extracted and catalogued for the agent, which is told to open the relevant document and read it directly before it answers, rather than improvising. When a question maps to your material, it goes to the source, finds the answer in what’s written, and cites where it came from. The result is replies grounded in your actual documents, not plausible-sounding inventions.

The agent doesn’t try to remember everything. It opens the right document at the right moment — and answers from what’s actually written there.

It remembers what was said

Your knowledge base isn’t the only thing an agent can draw on. Agents can also search their own past conversations — backed by a real vector store, so the agent can semantically find what was said before. A returning customer doesn’t have to re-explain their situation from scratch: context that came up earlier stays reachable, which makes follow-ups faster and far less frustrating.

Reference material vs. long-term memory

It’s worth being precise here. Your knowledge base is your reference material — the documents, facts and sources you want the agent to consult. That’s distinct from long-term memory, which is what an agent accumulates over time about how you work. You curate the first directly; both make the agent sharper.
- Files, URLs and documents — added in, text-extracted, read on demand.
- Instructed to look it up — open the document, don’t guess, cite the source.
- Conversation search — past chats stay within reach, backed by a vector store.
Build your agent’s knowledge base →
May 31, 2026
No-code automations: scheduled tasks that run themselves
The best work your agents do is the work you never have to ask for. That starts with the routine things happening on their own — on time, every time.

Recurring work, scheduled — no code

Automations on Agentura are no-code. In the Tasks tab you set up the recurring work you’d otherwise have to remember: a daily report, a chase on overdue follow-ups, a check that flags exceptions. Pick a cadence from one-click presets — hourly, every morning, weekdays at 9, weekly — or set your own schedule. No scripting, no developer in the loop — just the task and when it should run.

Each scheduled task can pull from your data sources and deliver where you need it — an emailed report, a follow-up message — so the routine things that always slip happen reliably instead of falling through the cracks.

Set a task once and it keeps running on its cadence, with each run’s status visible so you can see at a glance that the work actually happened.

Agents that act between messages

Most chatbots are asleep until someone types. Yours don’t have to be. A proactive heartbeat — on by default — lets your agents do work in the gaps — checking orders, chasing overdue follow-ups, flagging exceptions before they become problems. The agent isn’t just waiting to react; it’s keeping an eye on things and stepping in when something needs attention.

The customer hasn’t messaged yet, but the follow-up is already sent and the exception is already flagged. That’s the point.

Built to run on its own

Scheduled and direct tasks run on a hybrid, sessionless task engine — meaning they don’t depend on someone being in a live chat for the work to happen. A report fires on its schedule. A follow-up goes out when it’s due. An exception gets surfaced the moment it appears. Your agents keep working whether or not anyone’s watching.
- Scheduled tasks — recurring reports, follow-ups and checks, set with one-click cadences.
- No code — pick what runs and when; no scripting, no developer.
- Proactive heartbeat — agents act between messages, not just on cue.
From reactive to proactive

The shift is simple but it changes everything: instead of an agent that only answers when prompted, you get one that anticipates. Less dropped follow-up, fewer missed exceptions, and a team that handles the recurring work so you can spend your attention where it actually counts.

Automate the routine work →
May 30, 2026
Automated appointments & booking
“What time works for you?” is the most expensive sentence in your business. It’s also the one your agent can handle entirely on its own.

The booking dance, gone

Scheduling is death by a thousand replies: a customer asks for a time, you check, you offer, they counter, you re-check, you confirm. Every step is a chance to lose them. Your Agentura agent collapses that whole exchange into a single, smooth interaction — the customer asks for a slot, and the agent books it.

No phone tag. No “let me get back to you.” The conversation that used to take a day takes one message.

It checks availability for you

Your agent doesn’t guess at open times — it checks real availability before it offers anything, then books the slot itself. Out of the box it works from a built-in bookings system that keeps track of what’s taken; connect your Google Calendar and it checks your live free/busy there instead, so what it offers is what’s actually open. Either way, the agent always looks before it books, and a slot that’s already taken is rejected rather than double-booked.

And when a customer asks for a time that’s gone, the agent doesn’t just say no — it offers the nearest open slots instead, so the conversation keeps moving toward a confirmed appointment rather than stalling.

The customer asks for a slot. The agent checks availability and books it. That’s the entire interaction.

Wherever the customer is

Booking shouldn’t depend on which channel someone happened to use. Your agent can check availability and confirm appointments across channels, so a customer can lock in a time wherever they’re already talking to you — no “please call us during business hours,” no redirecting them to a separate form they’ll never finish.

Less back-and-forth, more booked

The math is straightforward. Every round of scheduling friction is a customer who might drift away; remove the friction and more of them actually book. Your team stops playing calendar middleman, and your agent quietly turns interest into confirmed appointments — available around the clock to take requests, and offering the slots that fit your working hours.
- Real availability — checked before booking, not guessed.
- Automatic booking — the agent confirms the slot itself.
- Every channel — wherever the customer is talking to you.
Let your agent handle booking →
May 29, 2026
One dashboard, smart alerts
A team of agents working across a dozen channels is only an asset if you can see it. Scattered tabs are how good work goes unnoticed.

Everything in one place

Every conversation — across every channel and every agent — lands in a single dashboard. You see your agents and whether they’re online, the tasks they’ve completed, and the alerts that need your attention, all in one place. No jumping between inboxes and apps to piece together what’s actually happening; the whole operation is on one screen.

It’s the difference between managing a team and chasing it. When everything reports to one place, you can actually run things.

Alerts that respect your attention

More visibility usually means more noise. Agentura’s smart alerts do the opposite — they surface what matters and stay quiet about what doesn’t. Your agents raise an alert when something genuinely needs a human — an escalation, a frustrated customer, a question they can’t answer, an error — rather than pinging you for every message. So your attention goes where it’s worth the most.

The goal isn’t to know about every message. It’s to know about the ones that need you.

Organized by project, never lost

If you run more than one project, the dashboard keeps them straight. Per-project unread badges show you exactly where activity is building, while cross-project notifications make sure nothing important slips just because it happened somewhere you weren’t looking. You stay informed across the whole picture without drowning in any one corner of it.
- One dashboard — every channel, every agent, every conversation.
- Smart alerts — what matters surfaces, the rest stays quiet.
- Per-project badges & cross-project notifications — informed, not overwhelmed.
Stay in control without hovering

The point of putting AI agents to work is to stop watching every conversation — but you still need to know the operation is healthy and that exceptions reach you. One dashboard plus smart alerts gives you exactly that: full oversight when you want it, silence when you don’t, and confidence that the things needing your attention will actually find you.

See your whole team in one view →
May 28, 2026
Plug agents into your systems: the API
An agent that lives only in a chat window is an island. An agent with an API is a component — one you can drop into anything you’re already building.

Reachable from your own code

Agentura exposes an external REST API, so your agents aren’t locked inside the platform. It’s plain HTTP and JSON, authenticated with a company-scoped API key — so any system you run, from your CRM to your ERP to a script, can call it. You can list and message your agents, read conversations, manage bookings and check usage, all programmatically from your own software. The agent becomes something you call — a capable part you wire into the tools your business already depends on.

That turns an AI agent from a destination customers visit into a building block you assemble with.

Webhooks, so it works both ways

Integration isn’t only about you calling out — it’s about events flowing back in. The platform also exposes webhooks, so external activity can trigger your agents instead of you having to poll for it. Subscribe to events like a new message, a new conversation or a new booking, and inbound email can wake an agent too. Something happens out in your stack, the agent hears about it, and the right action follows.

Call the agent when you need it; let the agent hear from your systems when something happens. Integration that runs both directions.

Built for developers

This is the layer for teams who want an agent as part of a larger workflow rather than the whole experience. If you’re a developer stitching together a process across several systems, the API lets the agent slot in as one well-behaved component — handling the conversational or judgment-heavy step while the rest of your pipeline does what it already does well. Mint a key and configure webhooks yourself from the portal.
- External REST API — agents, conversations, bookings and usage, reachable programmatically with an API key.
- Call it from your CRM, ERP or scripts — plain HTTP, so the systems you already run can reach your agents.
- Webhooks — let outside events trigger your agents automatically.
Your stack, with agents in it

The most powerful place for an AI agent often isn’t a standalone app — it’s woven into the workflow you’ve already built. With a programmatic API and webhooks on both ends, Agentura lets you do exactly that: keep your systems, and give them an agent that fits right in.

Plug agents into your stack →
May 27, 2026
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