Frequently Asked Questions

Palma is what lets you say yes to AI agents. Every person and every agent gets one connector carrying exactly the tools and Skills they're entitled to — with rules on what they can actually do, a human in the loop for anything risky, a record of everything that happened, and a bill you can explain.

MCP is the open standard that lets AI agents use your systems — backed by Anthropic, OpenAI, Google, Microsoft and AWS, and now stewarded under the Linux Foundation. It defines how a tool is exposed and how a client authenticates to a server. It does not decide which person may use which tool, on which records, whether a human should approve a call, or what it cost. Palma answers those questions, so you can adopt the standard without handing over control.

Enterprises taking AI agents out of pilot and into production. Security teams get the proof they need to approve it, platform teams get one place to control it, and finance gets a number they can explain. Day to day it's lived in by platform and AI engineers, security and compliance, IT and identity, and finance.

Because without one, every agent project becomes its own security project. Teams wire up their own servers, credentials end up scattered across laptops and config files, and nobody can say who's allowed to do what — so promising pilots stall at the review. Palma is what gets you past that. It's the difference between three agents in a pilot and three thousand in production.

A Space is one business case with a boundary drawn around it — "Sales Automation", "Engineering Copilot", "Finance Reporting". It decides which tools and Skills are in play, who can use them, what the rules are, and where the cost lands. You grow by adding Spaces rather than rebuilding. Some are for people working in chat or their IDE; others are for agents running on their own, with their own credentials.

A Pack is a ready-made bundle of tools and Skills for a common job — "CRM Basics", "Dev Workflow", "Observability Read-Only". Build it once and hand it to any team. New team or new use case: create a Space, attach the Packs, adjust the rules. That's how governance keeps up with demand instead of becoming the bottleneck.

A tool is a verb — "send an email". A Skill is the playbook that tells an agent when and how to use the verbs it already has: how your team actually closes the books, runs an incident review, or qualifies a lead. It's how your best operator's way of working reaches everyone else's agent.

No. Skills arrive over MCP, so they show up in whichever assistant your people already use, and every session resolves the current version. Update a playbook and agents are working from it within seconds — rather than from a copy someone pasted into a config months ago.

Every version is scanned before anyone can use it, and only a version that passes is ever served. Secrets pasted into a playbook are stripped before it's stored. Versions are fixed and never change underneath a running agent, so rolling back just means choosing an earlier one. You decide whether a Skill stays private, goes to named parties, or opens to the whole org — and a Skill that depends on a tool can't be attached on its own, it travels in a Pack, so a playbook never lands somewhere without the access it assumes.

Only if you allow it. Personal Skills are off by default, and when you switch them on they serve only the person who wrote them — nothing reaches a colleague without passing your review. Anyone using a Skill can flag it, backed by evidence from the actual run; maintainers work from a single inbox, and whoever raised it hears the outcome.

Yes — and it's usually the question that decides whether security signs off. Every action records the person it was done for, the agent that did it, and the application it ran in, whether that's Cursor, Claude Desktop or something you built yourself. No more staring at a single shared service account trying to work out who was behind it.

Down to the details of the request, not just the name of the tool. Most systems can only ask "is this agent allowed to use Salesforce?". Palma can ask "can it look up Salesforce accounts, in EMEA only, during business hours?". You can test a rule before it goes live, and run it in one of three modes: watch quietly, warn, or block.

Yes, and you decide how strict. One approver, everyone, or a set number of them. Approvals can trigger only when it matters — crossing team boundaries, or touching something critical. Deadlines, escalation and an emergency override are built in, and work moves through Draft, Dev, Test and Prod so nothing reaches production without sign-off.

A complete record of every action: who it was for, which agent, which application, which tool, what was passed, what came back, how long it took and what it cost. It's tamper-evident and you can verify it offline with your own key, so nobody has to take our word for it — and it streams into the SIEM you already run. Configuration changes are recorded too, with before-and-after detail.

It gives you the evidence. Obligations took effect on 2 August 2026 and penalties are tied to global turnover, so regulators expect you to demonstrate control over AI systems rather than describe it. That's what Palma produces: who authorised what, which rules were in force at the time, and a complete record of every action an agent took on your systems.

The evidence those frameworks ask for is what Palma produces by default — every action traceable, every decision logged, retention set to your policy. For where our own certifications currently stand, ask the team.

It's the main reason people buy it. The single biggest killer of enterprise AI pilots is that security and compliance can't approve what they can't govern. Palma turns a six-month review into a conversation about evidence you can already produce: what every agent did, that the rules held, who approved what, and what it cost.

Yes — broken down by business case, team, agent and person. You can say what each AI initiative costs instead of pointing at one unexplained line item, set budgets per Space, and produce chargeback reports finance will accept.

Yes. Set a limit per business case, per team or per agent, and Palma will warn you as you approach it or stop spend when you cross it. Worth doing early — agent spend grows quietly once more teams switch on.

This is the part people don't expect. Hand an agent forty tools and it picks the wrong one; hand it the eight that matter for the job and it gets further without going wrong. Spaces and Packs keep that surface small, and Skills supply your team's actual procedure — so the agent has both the right tools and the right way to use them.

It usually speeds things up. Once rules, Packs and Spaces exist, the next agent reuses them instead of restarting the security conversation from scratch. Rules can run in watch-only mode while you build confidence, so going live isn't a cliff edge. And a smaller, curated set of tools makes agents perform better, not worse.

It runs on your own infrastructure by default, so your data, credentials and audit logs never leave your environment — including fully air-gapped. Each tenant's encryption keys are separate. If you'd rather not run it yourself, we'll host it for you. Either way it's built for industries where data residency isn't negotiable.

It takes care of itself. Access follows your identity provider's groups, so a joiner has everything on day one and a leaver loses it the moment the group changes — no per-user setup, and no credentials left behind on a laptop. Works with Okta, Entra, Auth0 or any OIDC provider, with SCIM and SAML. People sign in with SSO; agents get their own credentials. Palma handles signing in to every system behind it, too.

The details of each tool call: which tool, which agent, for which person, what was passed and what came back. Personal data and secrets are spotted and removed on the way through, before the request reaches the tool, and sensitive fields are hidden in the logs. What gets kept, and for how long, is yours to set.

No — rather the opposite. Palma works at the MCP level, so it governs anything that speaks it: LangChain, CrewAI, AutoGen, Claude, GPT, Cursor, Claude Code, Windsurf, or something you wrote yourself. The same connector, Skills and rules follow each person into whichever assistant they open, and you can change model or framework without touching your governance.

An API gateway moves traffic — routing, rate limits, tokens. It can forward a request to an MCP server, but it can't look at what the agent is actually asking to do, hold it for someone's approval, hand out playbooks, or tell you what a business case cost. Palma governs the action, not the transport. We went through the differences in detail in MCP vs API.

Most were built to give one engineering team of five or ten a safer way to reach a handful of MCP servers. Palma was built for the whole organisation — every employee, every agent. And it doesn't only show you what happened, it decides what's allowed. That difference is architectural rather than a feature gap, so it widens as you scale instead of closing.

No. Palma is built on the open MCP standard and runs on infrastructure you control. What you invest in — well-defined capabilities, Skills and rules — stays yours and stays portable. And because it's agent-agnostic, you can change agents, models or frameworks without touching the governance layer.

By keeping governance separate from whichever framework or model is current. Integrations, Skills and rules live in one layer; agents and models come and go above it. You do the governance work once and it survives every model you adopt afterwards.

One or two use cases that touch real systems — developer copilot access, say, or a reporting agent that runs on its own. We govern those first, establish a baseline for security, cost and accuracy, then widen once the pattern holds. A first Space is running in about 20 minutes.

That's the best time. Governing from the start is far easier than retrofitting it across fifty agents and no audit trail. Work moves through Draft, Dev, Test and Prod, so you can start governed and promote to production when you're ready.

A first Space takes about 20 minutes: connect your MCP servers, let Palma find the tools, bundle the ones you want, set a rule, and you're live. A full rollout depends on scope, but there's no lengthy integration project — most enterprises go from first demo to first governed Space within a week.