For security
How is it secured, and who can see what?
The questions a review asks of Promenaut, answered from the platform itself, and everything built for them.
The questions, in the order they come.
Each deployment declares its sign-in methods from email and password, LinkedIn, GitHub and SAML single sign-on; a method not declared has no routes at all.
- Each deployment chooses how people sign inEach deployment declares which sign-in methods it offers, from email and password, LinkedIn, GitHub and SAML single sign-on.
- SAML single sign-onThe platform runs as a SAML service provider with the full flow implemented: login, assertion consumer service, metadata publication and single logout.
- Assertion security corpusSingle sign-on is tested against a corpus of hostile assertions covering signature wrapping, replay, expiry, tampering, audience and recipient mismatch and weak signature algorithms, with fixtures rebuilt at test time so signed assertions do not age out.
The full answer is in How Promenaut Is Secured.
Access is named permissions attached to roles, enforced in API middleware and mirrored in the interface.
- Role and permission modelAccess is granted through named permissions attached to roles, enforced in API middleware and mirrored in the interface so users are not shown actions they cannot take.
- Roles granted at team grainA role can be granted to a team, and the team's roles are copied into a person's own grants, at the scope of the team's own organisation (or its enterprise for an enterprise-level role), when they join it, or applied to all current members in one action, so a joiner picks up the team's entitlements without a sweep of individual grants.
- Teams of peopleAn organisation is subdivided into teams of people, each with named members, a lead, a slug and a place in a team hierarchy.
The full answer is in How Promenaut Is Secured.
Tenancy is two levels, an enterprise containing organisations, and every tenant row resolves to the organisation that owns it.
- Enterprise and organisation hierarchyTenancy is two levels: an enterprise contains organisations, and tenant data resolves to the organisation that owns it, either by carrying it directly or through the row it belongs to.
- Explicit organisation scopingOrganisation scope is passed as an explicit argument to tenant-scoped repository methods rather than inferred from ambient context or injected automatically.
- Usage insight cannot look across tenantsEvery usage insight resolves its organisation from the request and refuses without one, with no administrative path to read another tenant numbers.
The full answer is in How Promenaut Is Secured.
A workflow declares which knowledge domains it will write to before it launches, and the launch check applies the same domain permission rule as the write path, which remains the backstop.
- Declared write targetsEach workflow variant carries the knowledge domains it will write to, derived on every start-up from its agents' declared outputs, and only a declared, launcher-gated target subjects a launch to the write permission gate.
- Four-eyes on sensitive knowledge changesA domain can be marked as requiring approval.
- Governed promotion to a wider audienceMoving knowledge to a wider audience is a copy that keeps its lineage, and it passes two independent approval gates: one when the destination requires approval, and a second when the move would widen private or restricted personal data.
The full answer is in How Promenaut Is Secured.
Knowledge reads and writes are recorded with provenance, so who saw what can be reconstructed.
- Knowledge access auditingEvery knowledge read and write a module agent makes through the capability seam is traced to the activity log against its organisation and module, a run's repeated entity and relationship upserts, citations and find-or-create calls as one record per run with their count and a sample of the records touched.
- Administrative audit trailSecurity-relevant administrative changes are written to a hash-chained audit log with the actor, address and session recorded, covering users, roles, teams, access policies, single sign-on, security mode, cost centres, each agent's knowledge envelope and service identity, the definitions of domain, platform and service teams, and workflow configuration settings.
- A fixed set of operator actions against running infrastructureThe operator console exposes a closed set of named actions against live components: kill a run, pause or resume one, retry a message, pause a queue's intake, clear its waiting jobs or resume it, evict a checkpoint, restart or rescale a service, close a streaming connection, replay held event deliveries, reactivate a suspended agent, set the sandbox runtime new skill runs are given, set the install-wide cap on skill runs, keep a launcher pool's hosts up for a set time.
The full answer is in How Promenaut Is Secured.
A module agent reaches models only through the capability seam, which is what lets every call be metered, attributed and guarded.
- Capability seamThe sanctioned way a module agent reaches the platform is a declared set of twenty-one capability surfaces covering data, models, knowledge, artifacts, documents, files, workflow, events, notifications, service invocation, cost recording, decisions, questions that pause the run until the person who launched it answers, the settings a run launched with, autonomy policy, read tools on outside MCP servers, tool calls a model selects, skills granted to the agent, queues, secrets and logging, with the tenant it is bound to carried alongside them.
- One call, several model providersAgents run on models from Anthropic, OpenAI and Google directly, or on models hosted in Amazon Bedrock, through one call.
- Every model call through the client's own AI gatewayAn installation can send every model call, for every model family, through the client's own AI gateway instead of calling model providers directly, and knowledge-graph embeddings follow the same channel through the gateway.
The full answer is in How Promenaut Is Secured.
A module reaches the platform through the capability seam and runs its database access as named queries declared in its manifest.
- A descriptor card cannot express anything unsafeThe descriptor vocabulary is two forms: read a field by path, and format it.
- Declared data accessModule agents reach the database through named queries declared in the module manifest rather than composing SQL at runtime, so every query a module can run is visible in one place and reviewable before it ships.
- Module artifacts are signed and verifiedA module artifact is signed when it is built, and the installer refuses any artifact that is unsigned, badly signed, or signed by a different key from the one that signed the version already installed.
The full answer is in How Promenaut Is Secured.
Services and data stores run in private subnets with no public addresses, with the load balancer the one internet-facing component and security groups admitting each tier from the one above it alone.
- Compute and data sit off the internetServices and data stores run in private subnets with no public addresses.
- Encrypted at rest and on the way to the dataThe database, both Redis clusters, shared file storage and the object store are encrypted at rest.
- Credentials come from a secrets storeProvider keys, signing secrets, integration tokens and database and Redis credentials are held in AWS Secrets Manager and injected into services when they start, rather than set as plain configuration.
The full answer is in How Promenaut Is Secured.
An agent can be paused from its control plane, which suspends it so it is refused at its next dispatch, and resumed later.
- Agent handbrakeA platform administrator can pause an agent from its control plane, which suspends it for every organisation so it is refused at its next dispatch, and resume it later, with the agent's containment state and last transition shown alongside.
- Agent lifecycle audit logEvery lifecycle transition of an agent is recorded with its previous and new state, the reason given and who made it, and the log is shown on the agent and as a fleet activity feed.
- Editable agent classification ceilingAn administrator can set or clear the most sensitive classification an agent may reach, independently of its permitted knowledge domains.
The full answer is in How Promenaut Is Secured.
A read-only model risk console, observe-only by design, behind the auditor role's audit:read permission.
- Model risk oversight consoleA model risk console in one area with eight tabs, listed under Model Risk Management in the left-hand navigation, each at an address of its own so a view can be sent as a link: Overview, a live view that is read once and then follows a live stream, with no timed re-reads (four figures for the last hour; the share of checks passed in each minute of the last hour, with how many were judged; each model called in the last hour as healthy, recovering, failing or throttled, judged on its hard errors a minute against a set limit, with a model a throttle directive names read as throttled; the agents blocked, quarantined or suspended now, with who placed it, why and until when; the runs held waiting for a person, with the cause; what the platform did each second of the last minute; and the runs in flight that most need a look, each with its result) above a ranked list of what needs attention, in which failed runs and high findings come first, then a deprecated model still in use, warnings and medium findings, newest first within each, and each row linking to the run, the finding or the model register, and a coverage strip that says how much of the completed runs the validator could judge; Runs, the runs held waiting for a person, the runs in flight with the check each team passed, the finished runs of the last day by their result for each hour (a run that ended early counted under how it ended) and the events of the live stream as they arrive (by default the failures, warnings and actions), then one list of the finished runs across all workflows, newest first (the runs in flight can be listed there too), each with a single result (the worse of its recorded checks and its approved-agents verdict, so a run with an unapproved agent reads as failed, and a run that was stopped, failed or was cancelled leads with how it ended, there and on its own page, rather than as passed), which can be narrowed by result, workflow, person and a search over run, workflow, person and agent, and each run opening on its own page, whose address names the run and its organisation and whose header offers pause, resume and stop while the run is in flight to a person who holds those run controls: a timeline of the run with its teams as lanes, its agents as bars (each bar says how many attempts the step made and what its cost legs add up to), each team's check as a mark and its retries, fallbacks, tool calls and the pauses, resumes, stops, drains and kills applied to it as markers (a tool call shows the tool, how it ended, how long it took and what it changed, and not its arguments or its result, and a control shows who applied it), one verdict, then one list of what went wrong, each with what was expected against what happened and the evidence behind it, the run's cost as one figure with its parts by kind beneath it, which while the run is in flight includes what its agents still running have spent so far, shown as a part of its own, then the agents that ran and the records an auditor can quote; Workflows, one row per workflow showing what its runs came to, each opening on a page of its own with the workflow's runs, its rating and a roll-up of its agents' health (each agent's health shown as red, amber or green against thresholds that can be set per agent); Agents, a line naming any agents contained now, a map of the agents seen over the chosen date range, grouped by workflow, showing how each is doing and which are working now, then a list of the agents that ran, inside a workflow or not, worst health first, with its runs and failure rate, each opening on a page of its own that says whether the agent is contained and shows its declared boundary, its runs, its pass rate, retries and cost per run over the last 30 days, and the cost of those runs with its parts by kind; Findings, where a finding is an issue raised that needs attention, on one scale of high, medium and low (a failed agent run or check is high, a check that passed in part or repeated hard errors on an agent is medium, a run that failed and a retry answered is low, an agent whose recent behaviour has moved away from its own past is high or medium, a run far over a cost or time ceiling its agent declares is medium or high, and a finished run that a judge model reads as having drifted from the goal it was launched with is medium or high); four figures above (open high, open medium, needs a person, and raised in the last hour), issue counts by severity for each minute of the last half hour or each hour of the last day, as picked, the workflows that raise the most by hour of the last day, and the agents that raise the most, then an Open now list of the newest unresolved findings, from the agent runs and checks, from drift, declared ceilings and launch intent, and from the evaluators, with their severity, workflow, status and how long they have been open, which can be switched to resolved or all and narrowed by source, workflow and agent, and each finding opening beside the list with links on to its run, its agent and its workflow, and which can be shown instead as a board of the last day's issues in four columns by where they stand (detected, the system acting, resolved, and needing a person) with what the platform did about each; a check the evaluators recorded as failed or passed in part stays open as a high or medium finding, because nothing resolves it; a check that passed and the evaluators' scores are results, not findings, so they are not counted and are listed only under All, without a severity; Actions, a newest-first feed of what the platform and its people did about what was detected, each action beside the issue it answered and its outcome, filtered by kind and by outcome, under the last day's count by kind with how each kind's actions ended; Feedback, showing workflow-run ratings and how people relied on agent suggestions; and Platform, showing what the platform runs outside any workflow, with each agent's runs opening in the page.
- Agent call monitoringEach agent that ran inside a workflow is classified against the roster that run launched with: expected, adaptive (added by a rule that fired in the run), platform-enabled (a platform agent the workflow switches on, or one the platform runs on workflows by default, and the organisation has not withdrawn), delegated (run by a service team an approved agent is declared to call), unexpected, or no baseline, with a drill from workflow, each workflow on its own page, to run, each run on its own page, to agent.
- Run-end roster verdictWhen a workflow run ends, whether it completed, failed, was stopped, was cancelled or was ended by a containment rule, the platform records a content-free pass, fail or no-baseline verdict in the audit ledger on whether the agents that ran matched the roster the run launched with, and a run in which an agent called a service team its module did not declare also fails.
The full answer is in How Promenaut Is Secured.
What the platform does for you, layer by layer.
Client and market
- Mail Intelligence
Home and conversation
- What I spent today, and what my teams spent, without singling anyone out
Adoption insight
- Usage insight cannot look across tenants
Ways in
- Agents react to events from outside systems
- An MCP server for machine callers
- A module can publish a page without sign-in
Sources
- Client email is synced from named mailboxes
Actions out
- External API catalogue
- An agent reads from an approved outside MCP server through one checked, recorded call
- A guarded connection to outside MCP servers
- A document a person points the platform at is downloaded through a guarded fetch
Model gateways
- Every model call through the client's own AI gateway
Kinds and roles
- Assistant agents
Models and routing
- One call, several model providers
- Models chosen by where a person is
Guardrails and model limits
- Masked content is delivered; a block says why without saying what
Documents and media
- Documents are parsed by the platform
Fleet and control plane
- Agents allocated to a team
- Per-agent control plane
Teams and workflows
- An agent can call a service team mid-run
Handoffs and context
- An agent reads its own workflow's files and earlier outputs
Graph and search
- Knowledge graph
- A shared vocabulary of knowledge types
- Relationships walked with access checked at every hop
Domains and scopes
- Knowledge domains
- Sealed compartments and legal holds
- Firm-wide reference knowledge
- Five domain scopes
Access decisions
- Per-principal domain access
- One access decision surface
- Agents act as a resolved subject
- A read names who and why
- Ordered axes, first refusal wins
- Four answers, so a refusal can hide its own existence
- Reads degrade quietly, writes refuse loudly
- Declared write targets
- Per-agent knowledge exceptions
Governance controls
- What a firm can switch off, and what it cannot
- Classification an agent cannot choose
- Four-eyes on sensitive knowledge changes
- Output egress wall
- Break-glass access
- Knowledge access auditing
- Wrong data can be taken out of a knowledge graph and its earlier values put back
Promotion and submissions
- A domain declares what it will accept
- One tenant cannot decide what another accepts
- Governed promotion to a wider audience
Identity and access
- OAuth sign-in
- Teams of people
- Roles granted at team grain
- A module cannot speak for another module
- A narrowed deployment cannot be asked about what it does not ship
- Entitlement is applied before the message is understood
- Explicit organisation scoping
- The token says who you are, not what you may do
- Role and permission model
- Enterprise and organisation hierarchy
- Each deployment chooses how people sign in
- SAML single sign-on
- Assertion security corpus
- Safe operator actions without destructive authority
- Open or closed catalogue, per organisation
- Separated finance permissions
- Least-privilege reporting access
- A rendered document is branded for the tenant that owns it
- What tenant resolution reaches, and what it deliberately does not
- Editable agent classification ceiling
- Who each agent acts as, across the fleet
- Service identities are reviewed on a cadence
- A module agent cannot write into another organisation
- An administrator resets a password with a single-use link
- Administrators act only within their enterprise and authority
- Single-use links stored only as a digest
- Modules switched on for an organisation or for one team
Approvals, decisions and containment
- Dialled autonomy
- Agent handbrake
- Suspend an agent everywhere
- Platform staff can block an outside MCP server for every organisation at once
- An agent runs an approved public skill in a sandbox with no outside network, and its uses are recorded
- Containment rules drain, quarantine, pause or block matching work
- One governed door for stopping and containing work
- A held run waits for the decision that holds it
- Brakes on automatic control
- Containing work by what it touches
- A quarantined module's agents do not run anywhere
- An agent that keeps failing on its own configuration is contained automatically
- One place to govern MCP, in both directions
- One checked, recorded door for the tools an agent offers a model
- One Approvals screen for what the control engine is waiting on
- An approval gate holds matching runs or calls until a person decides
Model risk
- Model risk access audit
- Pausing and stopping work is requested through control directives, not through model risk
Audit trails
- Administrative audit trail
- Seam calls leave an activity record
- Old capability audit records are archived before they leave the database
- Audit ledger anchored outside the database
Capability seam
- Capability seam
- Declared data access
- A knowledge read that cannot be scoped returns nothing
- A module reads only its own secrets, for the organisation it runs for
Agent contracts
- Each agent is handed the earlier work it declares
Modules and manifests
- A module's own API routes, gated and kept off the raw database
Module interface
- A descriptor card cannot express anything unsafe
Build and release
- Per-tenant module profiles
- A bill of materials for what is inside a module
- Module artifacts are signed and verified
- A partner submits a module to intake and follows its review from the command line
- Release of a first-party module from its own repository
Services and data
- Installed modules sit on read-only storage
Estate security
- Compute and data sit off the internet
- Encrypted at rest and on the way to the data
- Credentials come from a secrets store
- Pipelines hold no cloud keys
- A change carrying a credential fails
- API calls and sign-in are rate limited
- Request bodies are limited before sign-in is checked
- An organisation's own certificate authorities, trusted by every service
- Spreadsheet exports guard against formula injection
- A skill script runs in the sandbox runtime the install chooses
Builds and releases
- Candidate and released are separate registries
- A client release with a fixable critical flaw fails
- Release rulesets applied from code
Deploying environments
- A client can run it in its own account
- A deploy checks every artifact before changing anything
- Each install gets the reference data meant for it
Operations and observability
- No email addresses or model output in logs
Weighing us against the tools you already know? See how we compare, with sources →
The full answers, written for you.
How Promenaut Is SecuredAbout 25 minutes
How Promenaut Governs KnowledgeAbout 12 minutes
Bring your security team.
A session with the people who built it: identity, tenancy, what an agent may read, and the evidence kept.
Promenaut
