aegisora

Aegisora sits between your AI agent and the systems it can act on.
Every tool call is evaluated at runtime before execution.

Why Aegisora?

AI agents can do more than generate text. They can call tools, access services, execute workflows, and take actions in external systems.

That makes runtime control a security boundary.

Aegisora provides an open-source runtime layer for evaluating agent actions before execution, applying governance policies, assessing risk, enforcing permissions, and producing an explicit decision:

ALLOW · BLOCK · ESCALATE

The goal is simple:

Let agents act — but never let them act without runtime control.

How It Works

Aegisora is designed to sit directly between an AI agent and the systems it can reach.

┌──────────────────────┐
│       AI AGENT       │
└──────────┬───────────┘
           │
           │  Tool / Action Request
           ▼
┌───────────────────────────────┐
│           AEGISORA            │
│        Runtime Security       │
│                               │
│  Identity · Permission        │
│  Policy · Context · Risk      │
└──────────────┬────────────────┘
               │
               ▼
        ┌───────────────┐
        │    DECISION   │
        └───────┬───────┘
                │
        ┌───────┼────────┐
        ▼       ▼        ▼
      ALLOW   BLOCK   ESCALATE
        │       │        │
        └───────┼────────┘
                ▼
          EXECUTION
                │
                ▼
        AUDIT / EVIDENCE

For the visual architecture overview, see Architecture documentation.

Core Capabilities

• Runtime interception — evaluate agent actions before execution.
• Policy enforcement — apply explicit governance rules to agent behavior.
• Permission control — restrict what an agent can do and which execution surfaces it can reach.
• Risk assessment — evaluate actions in context before they are executed.
• Decision enforcement — return ALLOW, BLOCK, or ESCALATE.
• Zero-trust execution — treat every agent action as requiring an explicit runtime decision.
• Audit and evidence — record security decisions as auditable runtime evidence.
• Provider-aware governance — designed to operate across modern AI provider integrations.

Runtime Security Model

Aegisora treats an agent's ability to act as a controlled capability rather than an implicit privilege.

Every request moves through a runtime decision path:

Agent Action
     │
     ▼
┌──────────────┐
│ Interception │
└──────┬───────┘
       ▼
┌──────────────┐
│   Security   │
└──────┬───────┘
       ▼
┌──────────────┐
│    Policy    │
└──────┬───────┘
       ▼
┌──────────────┐
│ Risk Assess. │
└──────┬───────┘
       ▼
┌──────────────┐
│   Decision   │
└──────┬───────┘
       │
   ┌───┼────────┐
   ▼   ▼        ▼
 ALLOW BLOCK  ESCALATE
       │
       ▼
   Execution
       │
       ▼
 Audit / Evidence

This creates a clear enforcement boundary between the agent's reasoning and the external systems it can affect.

Decision Model

Aegisora uses three explicit runtime outcomes:

The important property is that the decision happens before the action is executed.

Risk Classification

Aegisora evaluates agent actions in context rather than treating every tool call as equivalent.

The runtime can use factors such as:

• requested capability,
• selected tool or execution surface,
• applicable policy,
• permissions,
• contextual risk,
• and the consequences of allowing the action.

The result feeds the runtime decision:

LOW / ACCEPTABLE RISK
        │
        ▼
      ALLOW

HIGH / DISALLOWED RISK
        │
        ▼
      BLOCK

REQUIRES ADDITIONAL CONTROL
        │
        ▼
    ESCALATE

For the detailed implementation and security model, see Security documentation.

Governance Policies

Policies define what an agent is allowed to do at runtime.

A policy can be used to express governance requirements around:

• permitted capabilities,
• restricted actions,
• execution boundaries,
• risk thresholds,
• and escalation conditions.

The intent is to keep governance explicit, reviewable, and enforceable at runtime instead of relying only on prompts or application-level conventions.

Audit & Evidence

Runtime decisions should be observable and explainable.

Aegisora records security decisions as audit/evidence data so teams can understand:

WHO
  ↓
requested WHAT
  ↓
using WHICH capability
  ↓
under WHICH policy
  ↓
with WHICH risk assessment
  ↓
resulting in WHICH decision

This provides a traceable security boundary for agent activity.

Supported Providers

Aegisora is designed to work with modern AI agent stacks and provider integrations.

Current provider integrations include:

• OpenAI
• Anthropic
• Gemini

The runtime model is intended to remain provider-agnostic: the security and governance decision should be enforced at the runtime boundary rather than being tied to a single model provider.

Quick Start

Clone the repository and install the dependencies:

git clone https://github.com/aegisora-ai/aegisora.ai.git
cd aegisora.ai
pnpm install

Start the development environment:

pnpm dev

Then open the local development URL reported by Next.js.

For the live project, see the Live Demo.

Project Structure

At a high level, Aegisora is organized around a runtime enforcement path:

Agent
  │
  ▼
Runtime Gateway
  │
  ├── Security
  │
  ├── Policy
  │
  ├── Permission
  │
  ├── Risk Assessment
  │
  └── Decision
        │
        ├── ALLOW
        ├── BLOCK
        └── ESCALATE
              │
              ▼
          Execution
              │
              ▼
        Audit / Evidence

See Architecture documentation for the detailed architecture.

Examples

Allow a permitted action

Agent
  │
  └── Request tool execution
            │
            ▼
        Aegisora
            │
            ├── policy: permitted
            ├── permission: valid
            └── risk: acceptable
                    │
                    ▼
                  ALLOW
                    │
                    ▼
                Execute

Block a disallowed action

Agent
  │
  └── Request tool execution
            │
            ▼
        Aegisora
            │
            ├── policy: denied
            └── risk: unacceptable
                    │
                    ▼
                  BLOCK

Escalate an ambiguous action

Agent
  │
  └── Request tool execution
            │
            ▼
        Aegisora
            │
            ├── policy: requires review
            └── risk: unresolved
                    │
                    ▼
                ESCALATE

Security

Security is a first-class part of the project.

For the detailed security model, threat considerations, and security guidance, see Security documentation.

Please do not disclose security-sensitive information in public issues. For responsible disclosure, follow the project's security guidance.

Architecture

The core architectural principle is:

Agent → Runtime Gateway → Security → Policy → Decision → Execution

Aegisora is designed to enforce governance before an agent action crosses into the systems it can affect.

See Architecture documentation for the full architecture documentation.

Roadmap

Aegisora is being developed as an open-source runtime security and governance layer for autonomous AI agents.

The project roadmap focuses on strengthening:

• runtime policy enforcement,
• permission and capability controls,
• contextual risk assessment,
• auditability and evidence,
• provider and tool integrations,
• and production-grade governance.

See the repository's Issues and Releases for the current project status.

Contributing

Contributions are welcome.

Before opening a pull request:

1. Review the existing architecture and security model.
2. Keep runtime enforcement behavior explicit and testable.
3. Add or update tests for security-sensitive changes.
4. Keep documentation aligned with the implementation.
5. Explain the motivation and impact of non-trivial changes.

For project discussion and community collaboration, join the Aegisora Discord.

Community

• GitHub: https://github.com/aegisora-ai/aegisora.ai
• Live Demo: https://aegisora-ai.vercel.app
• Discord: https://discord.gg/8CM3PpQRT5
• Product Hunt: https://www.producthunt.com/posts/aegisora

License

Aegisora is released under the MIT License.