Open source / Self-hosted / Active development

Security-first agent runtime

Let agents learn and act. Keep authority in the runtime.

Comis is an open-source, self-hosted, security-first runtime for agents that work across sessions. It can carry qualifying experience forward as sourced, correctable guidance, while configured runtime controls decide what the agent may do.

Runtime authority gateDecision path
InputPrior guidance + new task
ModelProposes an action
Runtime checksenforced
  • Origin
  • Capability
  • Credential
  • Budget
AllowedDenied
Decision and evidence recorded
Guidance can influence a proposal. It cannot grant itself permission.

The control problem

Agent autonomy is a security boundary. What an agent learns becomes part of that boundary.

Prompt injection is not limited to one prompt when an agent can remember, run tools, start other agents, and return later. Useful learning and safe action need one control system.

The runtime is the software around the model that stores state, applies rules, runs tools, and records evidence. In Comis, that layer owns permission. Prompt text and learned text do not.

Signals that cross sessions

External content

can shape memory and later proposals

Shells and credentials

can turn a proposal into an outward action

Schedules and child agents

can extend reach across time and a task tree

Model proposes. Runtime decides.

Governed learning

How experience becomes reusable guidance.

Comis can carry qualifying experience across sessions with its source, evidence, usefulness, and correction history attached.

  1. recorded

    Qualify

    Consider the outcome, source trust, and usefulness of an experience.

  2. recorded

    Admit

    Validate candidate guidance and apply the configured evidence rule.

  3. recorded

    Reuse

    Surface sourced guidance in a later session without changing authority.

  4. recorded

    Correct

    Use later outcomes to promote, demote, retire, or preserve guidance.

The runtime

Four runtime pillars for bounded autonomy.

Security is not one filter. It is a connected set of controls around context, learning, tools, delegation, credentials, and evidence.

Govern context and learning

Keep lossless messages and tool results outside the active prompt. Recover selected details with ctx_search, ctx_inspect, and ctx_expand. Recall memory and admit learned guidance with trust, source, usefulness, and correction signals.

context recovery / provenance / correction

Keep authority outside the model

Apply capability gates, origin checks, scoped secrets, encrypted storage, and the optional Credential Broker outside prompt text. The model can request access; the runtime controls whether that access exists.

capabilities / origin / secrets / leases

Bound execution and delegation

Run typed dependency graphs with cache-aware parallel subagents. Share limits across the full task tree for spawn count, cost, tokens, time, rates, outward actions, and leases.

typed DAG / parallel fanout / tree limits

Explain, recover, and improve

Use cache-aware execution across Anthropic, OpenAI, and Gemini, context transforms, and graph fanout. Record execution evidence and assemble a bounded incident explanation without another model call.

cache trace / execution evidence / comis explain

Current evidence

Show what the agent learned. Show what stayed bounded.

A useful result names the workload, the state transition, the denied escalation, and the limits of the test.

Current governed-learning evidence
PropertyCurrent status
Guidance acceptedCandidate admissionInternally reproduced across catalog mechanisms
Reused in a new sessionFresh-session reuseReproduced in selected scenarios
Works with changed inputRotated-input transferReproduced in selected scenarios
Measured task improvementGeneral measured liftNot yet measured
Reproduced by another teamIndependent reproductionNot yet

Internal evidence, not an independent or customer result. Read the learning stress catalog for scenario scope and limitations.

Recorded incident evidence
comis explain <sessionKey|traceId|rootRunId>
Outcome
degraded
Attributed cost
$1.320669
Likely cause
Successful web content was classified as a failure.content_heuristic_misclassification
Model calls to explain
0
Comis explain builds a bounded report from recorded runtime evidence. It makes no model calls and does not invent a cause when no rule matches.

Security and deployment

Security-first, with explicit boundaries.

Comis treats model output and external content as untrusted, but safe operation still depends on your host and configuration.

What the runtime can enforce

Independent control layers

Layered authority

Privileged paths use capability gates, origin checks, scoped secrets, encrypted storage, and the optional Credential Broker.

Secure CLI path

CLI-driven autonomy can use jailed execution, capability-limited Unix sockets, expiring leases, and brokered credentials.

Interactive terminal

Persistent interactive terminals fail closed when the supported Linux isolation path cannot be established.

Whole-tree limits

Configured limits can cover the parent agent and every child it starts, including outward actions and leases.

What operators must decide

Current boundaries

Host isolation

Linux with Bubblewrap is the recommended target. macOS isolation is best-effort and does not provide the same boundary. Ordinary exec can reach the host when its sandbox is disabled or unavailable.

Defaults

The default tool profile is full and an empty per-agent secret allowlist is unrestricted. The approvals schema defaults off; guided setup enables it when it creates an administrator mapping. Approvals protect only explicitly wired paths. Narrow these before accepting untrusted input.

Learning

The default evidence rule can admit one owner's experience. It is not independent corroboration. Candidate text may affect tool selection, and validation does not catch every harmful instruction.

External systems

Self-hosted does not mean offline. Configured model, messaging, media, MCP, and tool providers may receive data you send to them.

Open evidence and community

Build it. Break it. Measure it. Improve it.

Comis Open Evidence is a planned public proof program, not a shipped benchmark suite.

Bring a workload, an attack path, a learning failure, or an integration. Leave a reproducible result or a maintained artifact.

Teams can own recurring workloads, deployment profiles, or adapters with a named maintainer, tested version, evidence link, and known limits.

Ways to contribute

  1. Learning and evaluation
  2. Runtime security
  3. Orchestration and operations
  4. Integrations and workloads

Quick start

Install Comis on a host you control.

The managed installer can add Node.js, host tools, and a background service. Direct npm install keeps host setup in your hands.

Start with a read-only workload on supported Linux isolation. Add tools, credentials, and write access only after testing your policy.

Read the installation guide
curl -fsSL --proto '=https' --tlsv1.2 https://comis.ai/install.sh -o comis-install.sh

Inspect, test, run

Read the file with less comis-install.sh, preview changes with bash comis-install.sh --dry-run, then run bash comis-install.sh.

Use npm

With Node.js 22.19 or newer, run npm install --global comisai, then comis init.

One-line convenience: curl -fsSL --proto '=https' --tlsv1.2 https://comis.ai/install.sh | bash. This skips local review of the installer.

Comis is an Apache-2.0 TypeScript project built around ports and adapters. Most code integrations are source-integrated and wired in the composition root.