✕

Security, infrastructure and uptime

Systems

An engine is worth only what keeps it alive.

Quant builds the engines. Systems holds the ground they stand on: one door, one watchtower, one hand on the switch. Below is the architecture — not a brochure of it.

You are already inside it. This request was filtered, timed and filed at the edge — ·

The architecture

Four stages and one hand. Every arrow is a decision; every decision is recorded.

THE PUBLIC INTERNET clients · markets · and everyone else 01 THE EDGE runs in 300+ cities · no origin host to find rules applied before the request becomes traffic clean 02 THE DOOR signed session · one key bound to one address three failed keys and it closes DEAD END no hint, no error, no second guess named 03 THE OPERATION engines feeds vault each part isolated from the next a breach in any single part reaches nothing else 04 THE WATCHTOWER every event, with its city, its network and its hour THE HAND permit or block — one tap alert that decision becomes a rule at the edge — in seconds, for good Nothing in this drawing is aspirational: this page is served through it.

Measured, not claimed

Four figures from the system you are reading this on.

1016
key space
combinations per access key — and each key opens for one address only
3
strikes
failed keys before the door closes and the attempt is filed with its origin
0
hosts exposed
there is no origin server to port-scan: the system is the edge
365
days of HSTS
a browser that has met us once will never speak to us in clear text again

What we hold

Three jobs. Nothing else is promised, and these three are not shared out.

Zero trust at the door

No account is believed because it arrived. Identity, key and origin are checked together, on every request, and a key that drifts from its address stops working.

A watchtower that reports

Uptime, latency, drawdown and intrusion on one board, in your own clock. You learn of an event from us — not from your clients, and not from a monthly report.

Systems that close themselves

On a breach the engine halts before it loses money, the path is sealed, and the state is rebuilt from the last clean one. Recovery is a procedure, not an improvisation.

The interface

The whole of what we place beside your engine — every line of it, with no dependencies and no hidden calls. Read it before you let it near your money. The engine room on our side stays closed; what runs in your house is yours to audit.

"""MatchTop · engine guard — the piece that sits beside your engine.
Standard library only. Nothing we did not write runs with these rights."""

import hmac, json, os, time
from hashlib import sha256
from urllib.request import Request, urlopen

KEY   = bytes.fromhex(os.environ["MT_KEY"])   # one key per engine, never on disk
EDGE  = os.environ["MT_EDGE"]                  # no address baked into the build
GRACE = 3                                     # one lost beat is the network. three is a decision.


def seal(payload: bytes, beat: int) -> str:
    """Every beat is signed and numbered. A replayed beat is not a beat."""
    return hmac.new(KEY, b"%d." % beat + payload, sha256).hexdigest()


def read_verdict(answer: dict, beat: int) -> str:
    """An answer counts only if it comes back signed, for this beat and no other."""
    ours = hmac.new(KEY, b"%d.%s" % (beat, answer["verdict"].encode()), sha256).hexdigest()
    if not hmac.compare_digest(ours, answer.get("seal", "")):   # constant time, always
        return "halt"                                          # unsigned is not trusted
    return answer["verdict"]


def pulse(engine, beat: int) -> str:
    payload = json.dumps({
        "engine":   engine.name,
        "at":       time.time_ns(),           # UTC nanoseconds. local clocks lie.
        "alive":    engine.alive,
        "latency":  engine.latency_ms,
        "drawdown": engine.drawdown,
    }, separators=(",", ":")).encode()

    call = Request(EDGE, payload, {
        "Content-Type": "application/json",
        "X-MT-Beat":    str(beat),
        "X-MT-Seal":    seal(payload, beat),
    })
    with urlopen(call, timeout=4) as answer:      # we dial out. nothing dials in.
        return read_verdict(json.load(answer), beat)


def guard(engine) -> None:
    beat, missed = time.time_ns(), 0
    while True:
        beat += 1
        try:
            verdict, missed = pulse(engine, beat), 0
        except Exception:
            missed += 1
            verdict = "halt" if missed >= GRACE else "run"   # silence is not consent

        if verdict == "halt":
            engine.halt()                     # stop the money first
            engine.seal()                     # then close the path
            return                            # and stay down until a human says otherwise

        time.sleep(engine.beat_seconds)

What cannot be copied

Not features we chose. The shape of the house.

The usual arrangement
Here
Who answers
A support tier working from a script. The engineer who built the system is not reachable — by design.
The engineer who built it. There is no one else to reach, and no one standing in between.
Each year
Another module, another line on the invoice. The system can only grow heavier.
We take out what you stopped needing. The system gets smaller — and so does what it costs you.
The decision
Lives in their console. You are notified, and then you wait for someone with the rights to act.
Lives in your hand. One tap and the engine stops, wherever in the world it is running.
When it breaks
They tell you that it broke. From there it is your problem to solve.
We built the engine too, so we go in and repair it. One house answers for both halves.
The fit
A product configured for you — out of the same one sold to thirty thousand others.
A system measured to you: your operation, your exposure, your hours, your clock.

None of that is a list of features, and that is exactly why it cannot be out-bid. A firm with a sales floor cannot hand you its engineer. A firm that must grow its invoice every year cannot take anything out. A firm that only watches cannot repair. They are not behind us — they are built differently, and they cannot cross over without ceasing to be themselves.

It is also why there is no price list on this page. We measure the operation first, and then we quote what we measured.

Tell us what must not stop

Two lines are enough. We read them ourselves and we answer ourselves — there is no queue standing behind this window.

It reaches one person, and that person answers. Nothing here is shared, sold or passed on.

Mr. MatchTop · matchtopalgorithm.ai