Controlled beta: Currently available through controlled beta evaluation with selected testers and research collaborators. Selected Licensed — Audit participants may receive a professional-scope onboarding and reporting bundle agreed in writing; details. Apply — Audit pilot

Loading pilot seat availability…

Maintain seat count in audit-pilot-status.json. 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.

Currently available through controlled beta evaluation with selected testers and research collaborators.

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 helps constrain exposure; it does not generate 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) → Constrained exposure
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 controlled 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 controlled beta evaluation.

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

Simulation-tested results from historical crisis windows. Coerentis blocks proposed trades that violate configured risk rules before execution.

May 2021 Crypto Crash

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

Unshielded Max DD: -47%
Constrained Exposure 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%
Constrained Exposure 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%
Constrained Exposure DD: -10%
Trades Blocked: 0
DD_BREACH: 0 trades
VOL_BREACH: 0 trades
REGIME_GUARD: 0 trades
No configured entries breached gates

No proposed entries during the sampled window breached configured gating thresholds; shielded drawdown shown represents simulated portfolio exposure under active constraints.

Totals reconcile as May 2021: 11 blocked trades + COVID 2020: 55 blocked trades = 66 blocked trades total. Drawdown ceilings were not directly breached during the sampled simulations; volatility gating constrained exposure prior to DD threshold escalation.

Drawdown Comparison: May 2021 Crypto Crash

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

Sample Blocked Trade Log: Visible Examples

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
2020-03-15 BUY BTC VOL_BREACH Volatility 94% exceeds limit 80% £912

Sample entries from the May 2021 and COVID 2020 simulations. 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
May 2021 (11) + COVID 2020 (55); FTX (0)
£4,600
Estimated Losses Prevented
£2,100 May + £2,500 COVID + £0 FTX
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. Risk weighting, Greeks, thresholds, and structural filters are modular and may vary across deployment contexts.

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. Framework outputs are experimental analytical signals intended for research, evaluation, and controlled operational testing. Coerentis 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 (contracted constraints). Currently available through controlled beta evaluation with selected testers and research collaborators.

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: Selected qualified sign-ups may receive a professional-scope onboarding and reporting bundle agreed in writing.

£199 /month

Compliance reporting, forensic logging, regulatory documentation

For funds and desks needing an audit trail

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

Uses the monthly or annual price shown above (toggle billing before clicking). Secure checkout; you’ll return here when done. Pilot perks are separate — we may confirm eligibility after payment.

Enterprise — Enforcement

Custom

Contracted constraint enforcement and middleware integration review

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

Covers discovery and solutioning; full fees and SLA stay in your signed order or SOW.

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 — your Stripe Product prices may differ

Ask about simulation

Configure recurring and one-time prices in Stripe; map them in Netlify env to match the buttons above.

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 deterministic safety rails are implemented and available for controlled beta evaluation. Deployment hardening, adapters, and operational infrastructure remain under active 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 commercial terms for controlled beta evaluation. Research 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

Plain-language answers on operational modes, log space vs live execution, and how Coerentis fits your stack. This page is informational only — it does not replace a signed agreement. Coerentis™ — 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-oriented 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 controlled operations, but the contract emphasis is auditability & documentation Middleware is configured so BLOCK is binding under the 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 controlled evaluation and review. Enforcement ties log space to execution so a BLOCK does not reach the market under the agreed 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 may choose to honour BLOCK in controlled operations, 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. Under contracted Enforcement wiring, disallowed trades do not 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, payments & legal posture

Does this website replace a signed contract or order?

No. Your signed order, licence, statement of work, or other written agreement with BoonMindX — and any terms presented at checkout — govern fees, deliverables, liability, and intellectual property. Website and FAQ text are marketing and explanation only. If anything conflicts, the signed / gated documents control.

How do Stripe card payments relate to what we’re buying?

Card and subscription billing run through Stripe (subject to Stripe’s terms and privacy policy). A completed checkout does not by itself expand rights beyond your commercial agreement: map each Stripe Product/Price to what your order or SOW actually sells (Audit, simulation add-on, enterprise deposit, etc.).

Questions on invoices or receipts should start with your Stripe email; contractual scope still follows your paperwork with us.

Is Coerentis offering investment or regulated financial advice?

No. Coerentis is infrastructure software. BoonMindX is not acting as your investment adviser, broker, or regulated intermediary. Nothing here is an invitation or inducement to trade. You take your own legal, regulatory, and tax advice. The product is aimed at professional trading and technology teams, not retail consumers.

Who is Coerentis for?
  • Quant and execution engineers building controlled evaluation 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.

Selected-participant Audit bundle - what is included?

For our Audit-first rollout, a limited number of qualified Licensed — Audit customers may receive a complimentary professional-scope onboarding and reporting bundle. It is not a promised cash amount, not a fixed menu of deliverables, and not a cash rebate. Exactly what you receive is whatever we agree in writing before kickoff.

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)

Applying or paying does not guarantee acceptance; we may waitlist or decline.

Patent pending — what should we tell legal or compliance?

Coerentis is patent pending. Website and docs are not legal, regulatory, or patent advice. We may change site copy without notice — freeze wording for diligence via counsel-approved materials.

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) controlled beta rollouts. Use this form for Shadow, Audit, or Enterprise — for the selected-participant Audit bundle, 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.

We’ll use your email for serious follow-up only. On the live site we typically send a short confirmation so you prove this inbox is yours before we queue your application (spam and impersonation control). If anything looks wrong, write info@boonmind.io.

Important — please read

  • Not advice. Nothing here is financial, investment, trading, tax, or legal advice. BoonMindX is not your regulated adviser; use your own counsel and compliance teams.
  • No guarantees. No promise of profit, loss prevention, fault-free operation, or fitness for any particular regulatory regime. Charts and simulations are illustrative, not forecasts.
  • What governs. Signed orders, licences, or statements of work — and Stripe’s terms for card checkout — define what you purchase. This site does not override them.
  • Pilot bundle. Audit pilot capacity is limited; onboarding and reporting scope is defined only in your signed agreement.
  • IP. Coerentis™ is patent pending. Public pages are not a substitute for patent or filing strategy with your lawyers.