agentura.

Agentura Blog

Tag: security

  • Real connectors: agents that act, not just chat

    Real connectors: agents that act, not just chat

    An agent that can only talk is a fancy FAQ. The interesting part starts when it can act — place the order, issue the invoice, mark it paid, read the file, generate the image, run the code. That’s what connectors are for.

    Conversation is the easy half. The half that actually moves your business forward is the part where something happens in a real system afterwards. Agentura agents are built to do the work, not just describe it.

    Real systems, real actions

    Connect your accounts and an agent can place WooCommerce orders and mark them paid, issue invoices through Oblio and SmartBill, raise and track PayPal invoices, read your Google Drive, send email from a real address, generate images, and run code. These aren’t canned integrations bolted onto a chat window — they’re tools the agent decides to use, in the middle of solving a problem, the same way a capable employee would.

    Because connectors are multi-instance and project-scoped, the same agent platform can serve a shop, an internal ops team, and a marketing project — each wired to its own accounts, none of them able to reach the others’.

    The model never sees your secrets

    Here’s the detail that matters most and gets talked about least: credentials stay encrypted, and the language model never sees them.

    API keys and passwords are stored encrypted and injected at the network edge, on the way to the real service. The agent calls a tool by name; it never holds the key.

    When an agent uses a connector, the request is routed through a proxy that attaches the right encrypted credential just before it reaches the external service. The key is never placed in the prompt, never returned in a response, and never exposed to the model. So even a cleverly manipulated agent has nothing to leak — there’s no secret in its context to begin with.

    An Agentura feature card describing one agent working across WhatsApp, Telegram, email, website chat and voice
    The same agent acts across every channel — and reaches the tools behind them.

    Add any tool — no redeploy

    Most platforms make “add an integration” a development project. Agentura treats connectors as a marketplace plus an on-the-fly gateway: the connectors above are free to switch on — you add one from the marketplace, drop in its credentials once, and its tools become agent skills almost immediately, scoped to the project that needs them, with secrets always encrypted. Running code is enabled from the start. You’re not waiting on a release to give an agent a new capability.

    The result is an agent that closes the loop. A customer asks for an invoice and gets a real one. A lead wants to order and the order is placed and marked paid. A teammate needs a document and it’s pulled from Drive. Less “here’s how you could do that,” more “done.”

    Connect your tools →

  • OS-level isolation, need-to-know by design

    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 →