Audit-first: First 10 qualified organisations on Licensed — Audit receive a complimentary extended audit, reporting, and onboarding package (we use “25k” as informal shorthand for a serious professional bundle — not a fixed price, currency, or deliverable list; details). Apply — Audit pilot

Loading pilot seat availability…

Maintain seat count in audit-pilot-status.json (commit & deploy). Engagement wording: scope template (Markdown).

Coerentis: The Deterministic Safety Layer for Algorithmic Trading

Block runaway algorithms before execution. Enforce max drawdown, volatility, and regime risk rules with our API-first, strategy-agnostic risk gateway.

Coerentis is not a trading strategy. It does not predict markets or generate alpha. It is a deterministic safety layer that evaluates proposed trades and blocks those that violate predefined risk, regime, or capital-preservation rules.

Algorithmic trading systems can spiral out of control—unchecked drawdowns, regime-blind execution, and silent failures. Coerentis sits between your strategy and capital, enforcing deterministic execution constraints, regime awareness, and explicit rejection reasons before trades reach the market. This risk-first infrastructure protects capital, not generates returns.

Patent pending Controlled Beta API-first Strategy-agnostic

The Cost of Being Unshielded

Unshielded Execution Coerentis Execution
Strategy signal → Immediate Execution Strategy signal → → Safety Gates → ALLOW/BLOCK → Execution
Silent failure → Blown-up account Structured log (e.g., DD_BREACH) → Protected capital
Regime-blind trades in a crash Regime Guard → "VOL_BREACH: Blocked"
Risk logic buried inside strategy code Centralized, strategy-agnostic safety gates

System Positioning

High-level view of where Coerentis sits in a trading stack.

Where Coerentis Sits: Strategy Engine → Coerentis → Execution Strategy / Signal Engine (any logic) • Signal generation • Alpha strategies trade intents Coerentis Deterministic Risk Gates • Drawdown limits • Regime filters • Trade sanity checks • Kill switch allowed trades only Execution / Exchange (broker / venue / API) • Order execution • Market access

A deterministic decision pipeline where the Safety Gates module applies all risk rules before any execution signal is allowed to pass through.

Strategy-agnostic integration Works with any trading strategy or signal generator
Deterministic gates (explainable) Same inputs produce same outputs with clear rejection reasons
Fail-closed defaults Safety gates block trades by default when uncertain

What Coerentis Is: Risk-First Trading Infrastructure

  • Execution + risk gateway - Strategy-agnostic infrastructure that sits between signal generation and market execution
  • Deterministic safety rails - Hard execution constraints with structured rejection reasons
  • Strategy-agnostic design - Works with any trading strategy, signal generator, or alpha engine
  • Simulation/validation harness - Test deterministic risk controls against historical market crashes

What Coerentis Is Not

  • Not a strategy — Doesn't generate buy/sell signals
  • Not a signal generator — Infrastructure, not alpha generation
  • No profit claims — Reduces risk, doesn't guarantee returns
  • Not financial advice — Infrastructure software only

Why now: The post-alpha era demands risk-first infrastructure. Coerentis provides deterministic safety gates that integrate into any trading stack, with validation tooling to measure the cost of safety before deployment.

Core Risk Management Capabilities for Algorithmic Trading

Deterministic Safety Rails

Max drawdown protection, regime guards, and health checks with structured rejection reasons. Deterministic execution constraints for algorithmic trading systems.

Capital Protection API

FastAPI-based REST API for risk-first trading infrastructure. Authentication, rate limiting, and structured logging for production deployment.

Explicit Rejection Reasons

Machine-readable decision codes (DD_BREACH, VOL_BREACH) for integration and logging. Transparent deterministic risk controls.

Simulation & Validation

Quantify Your Safety: See the Protection in Action
Test deterministic safety rails against historical market crashes. Compare baseline vs. shielded performance for algorithmic trading systems.

May 2021 Crypto Crash Simulation -10% limit

Visualization: A -10% max drawdown rule during the May 2021 crypto crash.

Download a sample simulation report (PDF)

Monitoring & Metrics

Health endpoints, performance metrics calculation, and real-time dashboard for trading infrastructure monitoring.

Preset Risk Profiles

Three configurations: Conservative (-5%), Balanced (-10%), Aggressive (-15%) drawdown thresholds. Strategy-agnostic risk controls.

Protection Evidence: What Coerentis Prevents

Real numbers from historical crisis simulations. Coerentis blocks trades that violate risk rules before execution.

May 2021 Crypto Crash

May 12-23, 2021 • BTC: -47% in 11 days

Unshielded Max DD: -47%
Shielded Max DD: -10%
Trades Blocked: 11
DD_BREACH: 0 trades
VOL_BREACH: 11 trades
REGIME_GUARD: 0 trades
£2,100
Estimated losses prevented

March 2020 COVID Crash

March 9-23, 2020 • BTC: -46% in 14 days

Unshielded Max DD: -46%
Shielded Max DD: -10%
Trades Blocked: 55
DD_BREACH: 0 trades
VOL_BREACH: 55 trades
REGIME_GUARD: 0 trades
£2,500
Estimated losses prevented

FTX Collapse

November 6-14, 2022 • BTC: -26% in 8 days

Unshielded Max DD: -26%
Shielded Max DD: -10%
Trades Blocked: 0
DD_BREACH: 0 trades
VOL_BREACH: 0 trades
REGIME_GUARD: 0 trades
No trades blocked (volatility within limits)

Drawdown Comparison: May 2021 Crypto Crash

Unshielded
Shielded (Max DD: -10%)
Drawdown Limit

Sample Blocked Trade Log: May 2021 Crash

Timestamp Signal Asset Rejection Code Reason Est. Loss Avoided
2021-05-19 BUY BTC VOL_BREACH Volatility 81% exceeds limit 80% £257
2021-05-19 BUY BTC VOL_BREACH Volatility 81% exceeds limit 80% £462
2021-05-19 BUY BTC VOL_BREACH Volatility 81% exceeds limit 80% £414
2021-05-19 BUY BTC VOL_BREACH Volatility 83% exceeds limit 80% £535
2021-05-19 BUY BTC VOL_BREACH Volatility 82% exceeds limit 80% £437

Sample entries from May 2021 crash simulation. Actual blocked trades logged with timestamps, rejection codes, and estimated losses avoided.

Key Protection Metrics (Combined Crises)

-47% → -10%
Max Drawdown Prevented
Worst case across all crises
66
Total Trades Blocked
Across all crisis periods
£4,600
Estimated Losses Prevented
Combined across all crises
11
Volatility Breaches Blocked
May 2021 crash
£912
Largest Single Loss Prevented
Single blocked trade

Methodology

These simulations use deterministic safety rules, not machine learning predictions. Coerentis evaluates proposed trades against configurable thresholds (max drawdown, volatility limits, regime guards) and blocks those that violate rules before execution.

Key principles:

  • Deterministic rules: Same inputs always produce same outputs
  • Configurable thresholds: Users set their own risk limits
  • Fail-closed defaults: If safety checks fail, trade is blocked
  • Strategy-agnostic: Works with any trading strategy

See technical architecture for detailed implementation

Disclaimers: Simulated results based on historical data. Past performance does not guarantee future results. Coerentis reduces risk but cannot prevent all losses. Not financial advice. User is responsible for configuring appropriate risk limits for their strategy.

Pricing

Operational modes: Shadow (observe), Audit (compliance and logging), Enforcement (live constraints)

Monthly Annual (2 months free — Licensed tier)

Free — Shadow

£0 shadow evaluation

Observe outcomes; no live enforcement on your system.

For teams validating fit before audit or enforcement

  • Shadow mode: observe allow/block decisions
  • No capital risk from enforcement on your stack
  • API access for evaluation (fair-use limits)
Request Shadow access
Audit pilot — 10 spots

Licensed — Audit

Intro offer: First 10 qualified sign-ups get the extended audit & reporting package at no extra charge (“25k” is just shorthand for the scale of bundle we’re talking about — not a fixed £ figure).

£199 /month

Compliance reporting, forensic logging, regulatory documentation

For funds and desks needing an audit trail

  • High-volume API for production documentation
  • Structured rejection reasons and logs
  • Priority support
  • Usage-based overages available
Get Audit license

Enterprise — Enforcement

Custom

Live constraint enforcement and full middleware deployment

  • Deterministic enforcement in your execution path
  • Unlimited API volume (contracted)
  • Dedicated support and custom SLA
  • Solutions architecture for middleware insertion
Contact Sales

Simulation-only add-on

Historical simulation and validation workloads alongside your commercial tier. Quote based on scope.

From £19/month or £149 one-time Illustrative; confirm in contract
Ask about simulation

Licensed tier: usage-based overages may apply beyond contracted daily API limits (£0.0001 per call unless otherwise agreed). Users can set a hard cap to prevent surprise bills.

Below is the internal module breakdown for technical readers.

Technical Architecture (Modules)
Strategy/Signal Coerentis API Safety Gates Execution Adapter Market Metrics/Dashboard Config Simulation
Metrics/Dashboard
Config
Simulation
  • Separation of concerns — Risk enforcement before execution
  • Integrates anywhere — REST API works with any trading stack
  • Deterministic decisions — Same inputs produce same outputs
Technical Appendix

Beta Status & Roadmap

Controlled Beta: Core API + safety rails are production-grade. Simulation adapters and deployment runbooks are under refinement.

Roadmap (Q1 2026 Public Release)

  • Additional data adapters (beyond CoinGecko)
  • Deployment runbooks (systemd/nginx templates)
  • Strategy-agnostic connector interface
  • Packaging + installer polish

Quickstart: Getting Started with Coerentis

Install
pip install -r requirements.txt
Run API
python -m app.main
Run Tests
pytest tests/
Run Simulation
python -m live_sim.quick_demo
Open Dashboard
http://localhost:8000/dashboard/

Licensing & Commercial Use

Coerentis is available under a commercial license for production use. Evaluation and internal testing are permitted under limited terms. Licensing is discussed case-by-case to accommodate different use cases and deployment requirements.

Frequently asked questions

Clear answers on operational modes (Shadow, Audit, Enforcement), what happens in log space versus your live execution path, and how Coerentis fits your stack. Patent pending — not legal advice.

Operational modes — execution path & log space

How do Shadow Audit Enforcement differ?

Think in two layers: log space (the durable record of each Coerentis decision) and the execution path (what actually reaches brokers or your internal OMS).

Shadow (free) Licensed — Audit Enterprise — Enforcement
Primary intent Observe & validate fit Compliance-grade logs & reports Live gates on the execution path
Typical log space Decisions recorded for analysis; you prove what would have happened Retained, exportable audit trail; structured reasons for review Full forensic trail plus operational runbooks
Execution path Your router usually ignores BLOCK for live orders unless you wire it; zero surprise enforcement You may honour ALLOW/BLOCK in prod, but the contract emphasis is auditability & documentation Middleware is deployed so BLOCK cannot be bypassed by strategy code under agreed architecture

All three can call the same APIs; the commercial mode describes what you are buying (observe, audit trail, or enforced deployment), not a different “secret” algorithm.

What is log space vs the execution path?

Execution path: strategy → risk/OMS → venue. Anything that can move capital or change exposure.

Log space: the parallel record of Coerentis’s decision for each check: timestamp, inputs you sent, ALLOW or BLOCK, and structured codes (for example drawdown or volatility breach labels). That record is what risk and compliance teams replay, export, or attach to internal tickets.

Shadow prioritises log space without mandating execution changes. Audit hardens log space for production scrutiny. Enforcement ties log space to execution so a BLOCK does not reach the market under the deployed design.

On Licensed — Audit, must we stop orders when Coerentis returns BLOCK?

Not automatically from the tier name alone. Licensed — Audit is positioned for teams that need defensible logging, exports, and documentation. Many desks still choose to honour BLOCK in production, but your order defines what you are purchasing.

Enterprise — Enforcement is for organisations that need the execution path wired so BLOCK is operationally binding, with solution engineering and SLAs as agreed.

Always align wiring with your counsel and your regulatory framework.

Product & risk

Is Coerentis a trading bot or signal service?

No. It does not generate alpha, rank names, or fire discretionary trades. Your strategy proposes actions; Coerentis returns deterministic allow/block style outcomes against thresholds you configure.

Does it guarantee profits or prevent all losses?

No. It is infrastructure to constrain tail scenarios and silent failures, not a performance product. Simulations and historical tests are illustrative; they are not promises of future results.

What is a runaway algorithm, and how does this help?

A runaway algorithm keeps trading or sizing in ways that breach risk bounds—often because checks are implicit in strategy code or because failures are silent.

Coerentis centralises gates (drawdown, regime, health-style checks) with explicit reasons. In Enforcement deployments, disallowed trades never reach execution; in Shadow/Audit, you see every would-be block in log space first.

Read how we frame runaway algos in the protection evidence section.

Max drawdown gate vs a stop-loss — what is the difference?

A classic stop-loss often reacts after a position is hurt. A drawdown-style gate evaluates whether the next trade would breach a configured portfolio or strategy drawdown limit before execution, returning a structured block where applicable.

Why does “risk-first” architecture matter?

When safety rules live only inside strategy code, they are hard to test, easy to bypass, and painful to explain to regulators. Separating signal generation from risk gates gives you independent tests, cleaner logs, and a single place to prove what blocked a trade.

Technical integration

How does integration work at a high level?

Coerentis is strategy-agnostic: send proposed trades or context over HTTPS with your API key; receive JSON with allow/block and reasons. Insert between signal generation and routing—see the integration guide for endpoints and a sample middleware pattern.

What are structured rejection reasons?

Instead of opaque “risk says no,” responses include machine-readable codes (for example labels corresponding to drawdown or volatility breaches) suitable for SIEM pipelines, spreadsheets, and audit workpapers—so reviewers see why a trade was blocked without reverse-engineering logs.

Is this deterministic rules or opaque AI?

Safety decisions come from explicit rules and thresholds you own, not from hidden predictive models. The goal is repeatable, explainable outcomes that stand up in internal and external review.

Can we self-host the API?

The stack in the repository is designed to run on your infrastructure (Python/FastAPI). You manage network isolation, TLS, key rotation, and backups. Managed offerings, if any, are defined only in contract.

API keys, browsers, and sensitive logs — any rules of thumb?

Treat keys as secrets (environment stores, never front-end). Keep Coerentis close to your execution stack network-wise. Classify logs like any trading data: retention, encryption, and access control are your policies—we provide structured payloads you can map into them.

Commercial & legal posture

Who is Coerentis for?
  • Quant and execution engineers building production or shadow stacks
  • Risk or technology leadership at funds, props, and systematic desks
  • Architects who need deterministic gates and credible log space—not retail signal chasers
What are the three commercial tiers in one sentence each?

Shadow — observe in log space without enforcing on live flow.

Audit — licensed emphasis on forensic logging, exports, and documentation.

Enforcement — enterprise deployment where BLOCK is binding on the execution path as engineered.

Pricing details are on the page above; annual options may apply for Licensed tiers.

First-10 Audit pilot — what does “25k” mean?

For our Audit-first rollout, a limited number of qualified Licensed — Audit customers receive a complimentary extended onboarding and reporting bundle. “25k” is informal shorthand for serious professional scope — not a promised cash amount, not a fixed menu of deliverables. Exactly what you receive is whatever we agree in writing before kickoff. Not a cash rebate.

Who qualifies for the Audit pilot?

Indicative criteria (we may decline or waitlist):

  • Registered company, fund, or professional trading firm
  • Systematic or algorithmic stack with a named technical owner
  • Willingness to start in shadow or non-production where appropriate
  • Ability to sign an engagement or order (see the scope template; counsel reviews)
Patent pending — what should we tell legal or compliance?

Coerentis is patent pending. Website and docs are not legal or patent advice. If you need language for filings, vendor due diligence, or marketing approvals, run final wording past your counsel.

Performance metrics, simulation screenshots, and historical tests are illustrative unless repeated in a controlled report you approve with advisors.

Apply — Audit pilot & access

We are prioritising Audit (Licensed) rollouts. Use this form for Shadow, Audit, or Enterprise — for the first-10 Audit bundle (the informal “25k” scope shorthand — see FAQ), select Licensed — Audit and we will confirm eligibility.

Engineering prerequisites: integration guide. Engagement wording: scope template (have counsel review).

We're prioritizing quant developers, trading system architects, and systematic traders building a durable compliance and risk log.

Submissions are delivered to our team at info@boonmind.io (and you’ll see a confirmation below once sent).

Disclaimer: No financial advice. No performance guarantees. Infrastructure only. Coerentis is patent pending; public materials are not legal or patent advice. Audit pilot: limited availability; “25k” is informal shorthand for bundle scale, not a guaranteed valuation or fixed deliverables unless your signed agreement says so.