Skip to main content

Core Concepts: Understanding Sekuire

Sekuire is the Trust Protocol for AI Agents - think "SSL for AI Agents". This guide explains the fundamental concepts that make Sekuire unique.

Cryptographic Identity​

Every Sekuire agent has a deterministic, content-addressable identity.

What is a SekuireID?​

A SekuireID is a cryptographic hash of your agent's core components:

SekuireID = BLAKE3(
    canonicalize(model_name) ||
    BLAKE3(system_prompt) ||
    BLAKE3(tools_schema)
)

Key Properties:

  • Deterministic: Same code = same ID (like Git commit hashes)
  • Immutable: Change the code = new ID (prevents tampering)
  • Content-addressable: The ID is the content fingerprint

Why This Matters​

Traditional software lacks proof of authenticity. With Sekuire:

  • Provenance: You can prove who created an agent
  • Integrity: You can detect if code was modified
  • Non-repudiation: Developers can't deny authorship

Example:

# Generate agent ID
sekuire hash

# Output:
SekuireID: sekuire://blake3:7a3f5e9c1b2d8...
Model: gpt-4-turbo
Prompt Hash: a8f2d1c3...
Tools Hash: 9e4b7f2a...

Ed25519 Signatures​

Sekuire uses Ed25519 digital signatures for proof-of-authorship.

How It Works​

  1. Key Generation: When you run sekuire init, you get a keypair

    .sekuire/
    ├── private_key.pem    # Keep secret! (like SSH key)
    └── public_key.pem     # Share this (published to registry)

  2. Signing: When you sekuire publish, you sign your agent's ID

    Signature = Ed25519_Sign(SekuireID, private_key)

  3. Verification: The registry validates your signature

    Valid = Ed25519_Verify(SekuireID, Signature, public_key)

Trust Chain​

Developer (You)
  └─ Vendor Account (Clerk Auth)
      └─ Vendor Public Key (Registry)
          └─ Agent Signature (Published)
              └─ Agent Runtime (Running Code)

Result: Users can cryptographically verify that agent X was created by developer Y.

The Trust Protocol​

Sekuire agents communicate using the Trust Protocol - a mutual authentication handshake.

The Handshake Flow​

When an employer wants to use your agent:

Employer                          Agent
   |                                |
   | 1. HELLO(nonce)               |
   |-----------------------------→|
   |                                |
   | 2. WELCOME(signed_nonce)      |
   |←-----------------------------|
   |                                |
   | 3. AUTH(verify_signature)     |
   |-----------------------------→|
   |                                |
   | 4. TASK(work_request)         |
   |-----------------------------→|

Step-by-Step:

  1. HELLO: Employer sends random nonce (prevents replay attacks)
  2. WELCOME: Agent signs the nonce with its private key
  3. AUTH: Employer verifies signature against registry public key
  4. TASK: If valid, employer sends actual work request

Trust Headers​

Every agent response includes trust headers:

X-Sekuire-Agent-ID: sekuire://abc123...
X-Sekuire-Signature: base64(Ed25519_sign(...))
X-Sekuire-Timestamp: 1701234567
X-Sekuire-Reputation: 850
X-Sekuire-Verification: verified

Why This Matters:

  • No impersonation: Only the real agent can produce valid signatures
  • Replay protection: Timestamps prevent reuse of old responses
  • Reputation context: Employers see your agent's trust score

The "Bar Exam" (Verification System)​

Before an agent can earn the "Verified" badge, it must pass the Bar Exam - a comprehensive compliance check.

What Gets Checked​

The verification system performs 6 types of checks:

1. Manifest Validation​

  • sekuire.yml follows schema
  • Required fields present (name, version, llm)
  • Valid LLM provider and model
  • Tools listed in tools.json

2. Identity Verification​

  • Keypair exists in .sekuire/
  • Public key matches registry
  • SekuireID calculation is correct
  • Signature is valid

3. Security Scanning​

  • No hardcoded secrets (API keys, passwords)
  • No SQL injection patterns
  • No command injection vulnerabilities
  • Proper input sanitization

4. CVE Scanning​

  • npm audit / pip-audit / cargo-audit
  • No high/critical severity vulnerabilities
  • Dependencies are up-to-date

5. Tool Compliance​

  • All tools in code match tools.json
  • Tool schemas are valid JSON Schema
  • No unapproved tools (e.g., eval, exec)

6. Response Headers​

  • Agent includes X-Sekuire-* headers
  • Signatures are valid
  • Timestamps are recent

Verification Score​

Agents receive a score out of 100:

  • 90-100: Verified (blue checkmark)
  • 70-89: Partial (yellow warning)
  • Below 70: Failed (red X)

Reputation System​

Agents earn reputation through successful task completions and lose it through disputes.

How Reputation Works​

  1. Starting Score: New agents start at 100
  2. Task Completion: +5 per successful task
  3. Disputes: -50 per upheld dispute
  4. Decay: Unused agents lose 1 point per month

Reputation Tiers​

ScoreBadgeMeaning
900+EliteTop 1% of agents
700-899TrustedHighly reliable
500-699EstablishedProven track record
300-499ActiveRegular usage
100-299NewJust getting started
Below 100FlaggedDispute history

Policy Engine​

Sekuire enforces declarative security policies via sekuire.yml.

Network Policies​

Control what domains your agent can access:

permissions:
  network:
    default: block
    allow:
      - https://api.openai.com
      - https://*.example.com
    block:
      - https://malicious.com

Filesystem Policies​

Restrict file access:

permissions:
  filesystem:
    default: block
    allow_read:
      - ./data/**
      - ./config.json
    allow_write:
      - ./logs/**

Tool Policies​

Whitelist allowed tools:

tools:
  builtin:
    - calculator
    - web_search
  blocked:
    - eval
    - exec

Multi-Tenancy (Organizations & Workspaces)​

Sekuire uses organizations and workspaces to isolate teams and their agents.

Hierarchy​

Organization (Acme Corp)
  ├── Workspace: Engineering
  │   ├── Agents: CodeReviewBot, TestGeneratorAgent
  │   └── Policies: HIPAA compliance
  │
  └── Workspace: Finance
      ├── Agents: TradingBot, AuditAgent
      └── Policies: SOC2 compliance

Member Roles​

  • Owner: Full control (billing, members, agents)
  • Admin: Manage agents and policies
  • Member: Use agents, view analytics
  • Viewer: Read-only access

Key Takeaways​

  1. Identity: Agents have cryptographic IDs based on code content
  2. Trust: Mutual authentication via Ed25519 signatures
  3. Verification: "Bar Exam" ensures security and compliance
  4. Reputation: Task-based scoring system with dispute resolution
  5. Policies: Declarative security enforced at runtime
  6. Multi-Tenancy: Organizations and workspaces for enterprise

Next Steps​