For engineering
Can our engineers build on it?
The questions a review asks of Promenaut, with what answers each on the platform, and everything built for them.
The questions, in the order they come.
- Domain module systemCapability ships as versioned domain modules.
- Per-tenant module profilesEach environment ships a declared set of modules resolved at build time, so two tenants can run different capability sets from one codebase without branching.
- A mistyped top-level manifest key is an errorA module manifest is checked by one validator that the platform loader and the SDK share.
- 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.
- Capability surfaces are versioned one by oneEach capability surface carries its own semantic version, and an agent can name the surfaces and versions it needs.
- A module agent cannot write into another organisationIn production a module agent that names an organisation other than its own on a knowledge, artifact, queue, cost, decisions or input-request call, or on a read of the run's settings, is refused, a cost record it writes is booked only on its own run's work item, and a notification addressed to someone outside its organisation is refused.
- Module-contributed interfaceA module ships its own interface and declares where it mounts into defined host surfaces, so adding a module to a build adds screens and actions to the product without a change to the host application's code.
- Module UI contractModule interfaces may import only from an allow-list, the SDK, the design system, the shared web data layer, the host interface contract package and named third-party libraries, and not from the host application's own files, so the host can change its internals without breaking every module that draws a screen.
- Token-based design systemThe interface is built from shared primitives drawing on role-named tokens rather than raw colours, so a theme change is a token change and not a sweep through components.
- Module scaffoldingA new module repository is bootstrapped from one command with a manifest, a harness test and a continuous integration workflow, and an agent or a question answerer is added to it with its class and its registration: entries in the module manifest that a platform host with the module registry reconciler writes at boot, or a migration carrying the insert shapes the platform tables require.
- Module test harnessModule authors exercise the capability surfaces in memory, so agent behaviour is testable without a database, queue or model provider.
- A module validates on its ownOutside the platform repository a module is checked on its own: manifest shape, that its package file and its manifest carry the same version, forbidden platform imports and model vendor SDK imports in the files it would ship, that the packages its shipped source imports are declared in its package file, the module identifier on its registration inserts, the named queries it declares (valid PostgreSQL, one statement, as many parameters as placeholders), the agents, teams and models its manifest and migrations refer to, its migration file names, that each route file it names is one file inside the module, that no route factory or scheduled job handler reads the database client it is handed, that each route permission it declares is a permission the platform holds or the module declares and matches a route its router serves, that its routes are built on the Express major the platform's API runs, that the entry file of each deliverable renderer, section renderer, workflow launcher, home widget and page it declares, and the module files it imports, do not inject raw HTML, call the network directly, touch cookies or storage or evaluate code, whether the agent and type identifiers it registers and the workflow types and variants its manifest declares are already owned by the platform or another module, and where its package would publish, which fails when the package would be readable by anyone or npm would refuse to publish it.
What the platform does for you, layer by layer.
Home and conversation
- What the deployment ships, module by module
Deliverables
- The set of forms is configuration, not code
Module screens and cards
- Module-contributed interface
- A module-specific deliverable looks like itself
- A distinctive card without shipping code
- A module adds next steps to a finished workflow card
- A module supplies its own launch-time field
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
- Account source of truth
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
Kinds and roles
- Declared agent intent
- Specialised agent implementations
- How an agent can be reached
- Typed agent roles
- Standalone agent execution
- Intent is worked out from how an agent is built
- Kinds of agent
Models and routing
- One call, several model providers
- Request settings adjusted to what each model accepts
- Native tool calling across model providers
Documents and media
- Voice primitive
- Documents are parsed by the platform
Registry and versions
- Capability registry
- Versioned, diffable agent configuration
Teams and workflows
- Domain, platform and service teams
- Workflows as composed teams
- Rule-triggered service teams
- An agent can call a service team mid-run
- One registry and one profile for every kind of team
- One registry and one profile for each workflow
- Each organisation sets its own values for a Workflow, and a run keeps its copy
Handoffs and context
- Shared I/O type system
- What an agent in a workflow is offered, and what it takes
- A team whose agents do not actually connect
- The living requirements document goes to named roles
- An agent reads its own workflow's files and earlier outputs
- An edit proposal is checked before it is used
Conversation to work
- Platform-wide and module-specific capabilities
Execution
- Fan-out over a derived task list
People in the loop
- A module can ask the person who launched the run, and the run waits
Graph and search
- Knowledge graph
- A shared vocabulary of knowledge types
Access decisions
- Declared write targets
Promotion and submissions
- A domain declares what it will accept
- A submission travels whole or not at all
- Each domain chooses how versions accumulate
Identity and access
- A module cannot speak for another module
- Least-privilege reporting access
- A module agent cannot write into another organisation
Approvals, decisions and containment
- One protocol for decisions a person must make
- No outside MCP server reaches an agent until it is approved by a second person, or by a super admin who registered it
- An agent runs an approved public skill in a sandbox with no outside network, and its uses are recorded
Model risk
- Contract truthfulness monitoring
Credits and budgets
- A module's model calls are attributed to its run
Capability seam
- Capability seam
- A module Agent reads the settings its run launched with
- Declared data access
- One parser version, owned by the platform
- A knowledge read that cannot be scoped returns nothing
- Seam use is measured per module
- Capability surfaces are versioned one by one
- A module reads only its own secrets, for the organisation it runs for
Agent contracts
- Declared I/O contracts
- Declared side effects
- Each agent is handed the earlier work it declares
Modules and manifests
- Domain module system
- Atomic module add and remove
- Module-owned agents are read-only at the API
- A module states the platform it needs
- A mistyped top-level manifest key is an error
- A deliverable is declared in the manifest
- A module states its own governance position
- What is inside each installed module
- Agents, teams and workflows declared in the manifest
- A module's own API routes, gated and kept off the raw database
Module interface
- A descriptor card cannot express anything unsafe
- A module installed after the build still draws its own interface
- Interface registries are generated per profile
- Module UI contract
Agent building blocks
- Shared weighted scoring and conformance scorer base
- Shared base for agents that explain a computed result
- Modules inherit the platform's result, scoping and input methods
- A conversational answerer is a provider on a shared loop
- Reports are composed as a typed model
Authoring and testing
- Module authoring SDK
- Module scaffolding
- Module test harness
- Any agent, shown as SDK code and by source
- Run one agent or one workflow from the command line
- A module validates on its own
- The whole platform on a module author's own machine
- A module design is checked against what the SDK can build
- A design is checked for completeness, reuse and how each agent will be proven
- A module design pack for review
- A design becomes a module scaffold and an engineering handoff
Build and release
- Per-tenant module profiles
- A module builds against the published SDK alone
- promenaut-build CLI
- A bill of materials for what is inside a module
- Module artifacts are signed and verified
- SDK packages released in dependency order
- 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
- Layered migration system
Estate security
- An organisation's own certificate authorities, trusted by every service
Weighing us against the tools you already know? See how we compare, with sources →
The full answers, written for you.
The Promenaut SDK at a GlanceAbout 10 minutes
Bring your engineers.
See what a module is, how its agents are written and tested, and how it ships.
Promenaut
