Metadata-Version: 2.4
Name: qae-safety
Version: 0.1.1
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: Other/Proprietary License
Classifier: Programming Language :: Rust
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Software Development :: Libraries
Summary: Deterministic safety certification kernel for AI agents, finance, and beyond
Keywords: safety,certification,ai-safety,constraints
Author-email: William Tennant <bill@northbeam.solutions>
License: BUSL-1.1
Requires-Python: >=3.9
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Documentation, https://qaesubstrate.com/docs
Project-URL: Homepage, https://qaesubstrate.com
Project-URL: Repository, https://github.com/northbeam-solutions/qae-safety-kernel

# qae-safety

Deterministic safety certification kernel for AI agents, finance, and beyond.

Built with Rust for performance, exposed to Python via PyO3.

## Installation

```bash
pip install qae-safety
```

## Quick Start

```python
from qae_safety import SafetyCertifier, AgenticAdapter, SimpleAction, StateDelta

# Create an adapter with budget and rate constraints
adapter = AgenticAdapter(budget_limit=100.0, rate_limit=50.0)

# Create a certifier
certifier = SafetyCertifier(adapter)

# Define an action
action = SimpleAction(
    action_id="act-1",
    agent_id="my-agent",
    state_deltas=[
        StateDelta("budget_utilization", from_value=0.0, to_value=50.0),
    ],
)

# Certify the action
cert = certifier.certify(action)
print(cert.decision)  # e.g. "Certified"
print(cert.zone)      # e.g. "Safe"
print(cert.margins)   # e.g. {"budget": 0.8, "rate": 0.95}
```

## Convenience Function

For one-off certifications without creating a `SafetyCertifier`:

```python
from qae_safety import AgenticAdapter, certify_action

adapter = AgenticAdapter(budget_limit=100.0, rate_limit=50.0)
cert = certify_action(
    adapter,
    action_id="action-1",
    agent_id="my-agent",
    deltas={"budget_utilization": 0.5},
)
print(cert.decision)
```

## Custom Domain Adapters

Extend the kernel to any domain by subclassing `DomainAdapter` and `ConstraintChannel`:

```python
from qae_safety import DomainAdapter, ConstraintChannel, SafetyCertifier, SimpleAction

class TemperatureChannel(ConstraintChannel):
    def name(self) -> str:
        return "temperature"

    def evaluate(self, state: list[float]) -> float:
        # Return margin in [0, 1]; 1 = safe, 0 = at boundary
        temp = state[0]
        return max(0.0, 1.0 - temp / 100.0)

    def dimension_names(self) -> list[str]:
        return ["temperature"]

class RoboticsAdapter(DomainAdapter):
    def domain_name(self) -> str:
        return "robotics"

    def constraint_channels(self) -> list:
        return [TemperatureChannel()]

    def map_action_to_state(self, action) -> list[float]:
        for delta in action.state_deltas:
            if delta.dimension == "temperature":
                return [delta.to_value]
        return [0.0]

    def detect_regime_change(self, current, proposed) -> bool:
        return False

adapter = RoboticsAdapter()
certifier = SafetyCertifier(adapter)
```

## License

BSL-1.1 (Business Source License 1.1). Converts to Apache 2.0 on 2032-01-01.

