FortSignal DeepAgents

Deep Agents with FortSignal enforcement — every risky tool call cryptographically authorized before execution.

Every risky operation (file write, edit, execute, sub-task) is intercepted and routed through FortSignal's challenge/verify flow — only cryptographically signed intents reach your machine.

Free dev account

500 governed verifications/month, no card. Sign up at fortsignal.com/signup — API key in two minutes, passkey-only.

Before you start

1. API key — Sign up at fortsignal.com/signup → Dashboard → API Keys. Your key starts with fs_live_.
2. Register your agent — In the dashboard, create an agent and generate an Ed25519 keypair. Download the private key as agent-key.json.
3. Create a policy — In the dashboard, create a policy defining what the agent may do (see Policy Setup for a coding-agent example). You select this policy when delegating in step 4.
4. Approve a delegation — In the dashboard, approve a delegation with your passkey. Agent calls return delegation_invalid until this is done.

Install

pip install fortsignal-deepagents

Quick Start

Agent mode (autonomous — Ed25519 signs each challenge automatically):

export FORTSIGNAL_API_KEY="fs_live_..."
export FORTSIGNAL_AGENT_ID="your-agent-id"
export FORTSIGNAL_AGENT_KEY="/path/to/agent-key.json"

fortsignal-deepagents --model "openai:gpt-4o"

Human mode (passkey approval required per risky action):

export FORTSIGNAL_API_KEY="fs_live_..."
export FORTSIGNAL_USER_ID="your-user-id"

fortsignal-deepagents --model "openai:gpt-4o"

One-shot prompt:

fortsignal-deepagents --model "openai:gpt-4o" --message "create hello.py with a greeting"

Agent key file

FORTSIGNAL_AGENT_KEY points to a JSON file with your Ed25519 private key:

{ "privateKey": "<base64url-encoded Ed25519 private key>" }

Generate from the dashboard (recommended), or create it manually:

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
import base64, json

key = Ed25519PrivateKey.generate()
priv = base64.urlsafe_b64encode(key.private_bytes_raw()).rstrip(b"=").decode()
pub  = base64.urlsafe_b64encode(key.public_key().public_bytes_raw()).rstrip(b"=").decode()

with open("agent-key.json", "w") as f:
    json.dump({"privateKey": priv}, f)

print("Public key to register:", pub)

Register the public key in the dashboard, then approve a delegation before running.

How it works

1. Agent calls a risky tool → FortSignalMiddleware intercepts it
2. /challenge/start — challenge bound to exact action + target
3. Agent signs with Ed25519 (autonomous) or human signs with passkey (human-in-the-loop)
4. /challenge/verify — only verified intents execute

Risky tools intercepted: write_file, edit_file, execute, eval, task, write_todos

Read-only tools pass through without any verification check.

Execution artifacts

Every allow from /challenge/verify returns an artifact — an Ed25519-signed JWT receipt bound to the exact action parameters (action, recipient, amount, source, metadata). Denies never carry one: absence of an artifact IS the deny. The middleware attaches signalId + artifact to every approved tool call's additional_kwargs["fortsignal"] — persist it with your run logs; it is cryptographic proof of what was authorized, verifiable offline against FortSignal's public JWKS (https://api.fortsignal.com/.well-known/fs-keys.json).

Python API

from fortsignal_deepagents import create_fortsignal_deep_agent

agent = create_fortsignal_deep_agent(
    model="openai:gpt-4o",
    agent_id="my-agent-id",
    agent_key_path="/path/to/agent-key.json",
)

Or use the middleware directly:

from fortsignal_deepagents import FortSignalMiddleware
from deepagents import create_deep_agent

middleware = FortSignalMiddleware(
    agent_id="my-agent-id",
    agent_key_path="/path/to/agent-key.json",
)
agent = create_deep_agent(model="openai:gpt-4o", middleware=[middleware])

Environment variables

Development

git clone https://github.com/fortsignal/fortsignal-deepagents.git
cd fortsignal-deepagents
uv sync
uv run pytest

Full detail → api.fortsignal.com/docs

Tests

73 tests — all mock (middleware logic), no API key required.

Mock tests run offline and cover config, safe-tool passthrough, risky-tool interception, challenge/verify flow (agent + passkey modes), retry logic, API error handling, and middleware injection.

uv run pytest tests/ -v

Policy Setup

After creating an Agent Passport, create a policy in the FortSignal dashboard to define what the agent can do. Two rules to know: leave Allowed actions empty and every action is permitted — list any and only those pass. Same for recipients: empty means any target, listed patterns gate each call. A tool call that doesn't match the policy is denied and never executes.

Example for a coding agent:

The cmd: prefix is added automatically by the middleware to execute commands so they match the per-action policy overrides. The task: prefix is added similarly for task descriptions.

Execution budgets and human escalation (optional):

• Max actions (actionBudget) — e.g. 50 actions/hour per delegation; over the cap denies with action_budget_exceeded
• Total amount budget (amountBudget) — cumulative amount cap per fixed window; denies with amount_budget_exceeded
• Always require human approval (requiresHuman) — listed actions (or *) always deny for agents with requires_human; the middleware will tell you to rerun in human mode (FORTSIGNAL_USER_ID) to approve

Multi-sig: delegations can require M-of-N passkey approval (dashboard → Team card to invite co-signers; approval links arrive by email; the agent can't act until the threshold activates the delegation).

License
MIT © FortSignal