K-SAT AyguFX AI

K-SAT AyguFX AI

The decision-support platform that makes a committee of experts argue, then submits the verdict to a deterministic risk engine

K-SAT AyguFX AI is a decision-support platform: it has a committee of specialist agents analyse market data, puts the resulting decision through a deterministic risk engine, and executes it over MetaTrader 5 only if it clears that check.

This is not a "trading bot". The goal is not to place more orders but to make the way a decision is reached auditable: better information, better decisions, controlled risk, repeatable execution, and learning after every trade. The most successful answer the system can give is often to open nothing at all.

The chain below runs in order and no link can be skipped. Without positive approval from the risk engine and the risk officer no decision is executable; no consensus score can override a risk limit.

PythonFastAPIPostgreSQLRedisSQLAlchemy / AlembicMetaTrader 5ClaudeNext.jsDockerPytest
K-SAT AyguFX AI

Link 1 β€” The committee of specialist agents

Instead of one opinion from one model, a committee works, each agent looking at its own domain.

  • Nine analysis specialists. Technical structure, price action, candlestick patterns, support and resistance, quantitative measurement, market regime, macro news flow, sentiment and historical analogues β€” a separate agent for each.
  • Disagreement is not suppressed. Agents can read the same data and reach different conclusions; rather than hiding that gap, the system carries it into a debate stage and derives the consensus from there.
  • The portfolio manager gathers it up. The committee's output is not an order on its own: a portfolio-manager agent weighs it against open positions and allocation.
  • Data is validated first. The chain does not begin with market data but with a freshness and consistency check on it. If the data is doubtful, the committee never convenes.

Link 2 β€” Deterministic risk engine and CRO veto

The final controller is not a language model. It is deliberately deterministic: the same input always gives the same result, and the reason is readable.

  • A model cannot loosen a limit. However strong the consensus, a decision that breaches a configured risk limit is not executed.
  • The risk officer's (CRO) veto. A second gate above the engine; without positive approval the chain does not advance.
  • Configuration lives in files, not in code. Risk parameters, symbol definitions, agent settings and the economic calendar sit in separate configuration files β€” changing them does not require writing code.
  • Fail-closed. When something goes wrong with the connection, the data or the database, the system's answer does not stay ambiguous: it is always "no trade".

Link 3 β€” The prop firm rule engine

A breach on a prop firm account cannot be undone; the account is gone. So the check happens before the order, not after it.

  • The breach is caught by projection, before it exists. The engine asks: "if this position runs all the way to its stop, do I break the limit?" If yes, the position never opens.
  • Real contract rules are modelled. Daily loss limit, static and trailing maximum drawdown, profit target, minimum trading days, consistency rule, lot ceilings and the news, weekend and overnight-carry prohibitions.
  • An unverified rule does not run. Until the rules have been checked against your own contract and marked confirmed, the engine approves no trade at all β€” a guessed rule is not a rule.

Link 4 β€” Execution and safety gates

Even an approved decision does not go straight to the market: a separate safety layer sits in between.

  • Execution is closed by default. Order sending is opened by a dedicated switch behind a separate approval gate. The default mode works on paper.
  • The risk of connecting to the wrong broker is closed. If the account type and the server name contradict each other, the system does not start at all; the terminal path must be stated explicitly.
  • Pending-order management and position monitoring. An order stays watched after it is sent; position state feeds back into the chain.
  • Separated rights. Read and execute are two distinct tokens; the interface is given read only.

Link 5 β€” Living knowledge base and post-trade reflection

Every closed trade becomes a record that feeds the system's next decision.

  • Post-trade reflection. A dedicated agent judges the outcome: was the decision right for the right reason, or did a good result come from a bad one?
  • Two knowledge stores, never mixed. The typed, sourced base the agents read is separate from the raw research library where the human works. Moving from one to the other must pass a source and type check.
  • No claim without a source. The knowledge base is protected by a lint gate: a note with no grounding cannot enter an agent's decision.

Cockpit and API

The system is not a black box: the reason behind every decision is readable on screen.

  • The decision chain is visible. Which agent said what, where consensus formed, what the risk engine cut β€” the whole path is traceable.
  • The token never reaches the browser. The interface server acts as an intermediary; the API key never lands on the client.
  • Programmatic access. The same chain is consumed over an HTTP API and plugs into your own tools.

The honesty gate

The most unusual thing about this product is what it refuses to claim about itself.

  • No proven edge is claimed. In-sample and out-of-sample measurements are reported separately, and a weak out-of-sample result is not hidden. Measurement is not sacrificed to a marketing sentence.
  • Multiple-trials accounting. Backtests are run walk-forward and account for how many strategies were tried β€” try long enough and something always looks like it "worked".
  • Acceptance criteria are explicit. What the system passed, and what could not be measured without a live terminal, are written down separately.
  • This is not investment advice. The platform is a decision-support and risk-governance tool. Real-money use is not enabled before every safety and test gate has been passed.

Getting started

  1. Scope and rules. Your symbols, your risk limits and, where applicable, your prop firm contract go into configuration; the rules are verified against the contract.
  2. Infrastructure. Database and cache brought up, terminal connection and account type verified.
  3. Free end-to-end demonstration. The whole chain is run and watched without a single model call.
  4. Paper running in parallel. The system produces real decisions on the real market; no orders are sent, the decisions are measured.
  5. Controlled opening. Execution is opened only after acceptance criteria and measurements have been reviewed together, by a separate approval.

Could this run at your company?

Describe your operation in two lines. You get a costed scope back, not a brochure.

Or call us directly +32 460 25 64 64
WhatsApp Β· Brief 24h