What we run

The whole ground, as four jobs that never stop — not a tool you have to drive yourself.

How it is controlled

The difference is not a flashy dashboard. It is the watch — and nothing acts on your systems on its own.

Measured, not claimed

How the ground is held — not invented growth figures.

The build — what watches, what guards, what proves

The agents are not the show; they are one more managed layer under the same watch. Here is the real shape of it.
The code stays in English — the universal language of engineering.

# one house under watch — what raises a hand, and what it does on its own (nothing)
POST https://api.matchtopalgorithm.ai/v1/operate/hosts
Authorization: MT-••••-••••-••••      — one key, one house
Content-Type: application/json

{
  "host":    "prod.yourcompany.com",
  "watch":   ["uptime", "certs", "backups", "intrusion"],
  "on_breach": { "alert": ["telegram", "email"], "act": "propose_only" },
  "window":  "24/5",
  "clock":   "Europe/Zurich"        — the sheet arrives in your hour
}

202 Accepted
{
  "host_id":   "h_5c2e80b1",
  "watch":     "live",
  "autopilot": "off — a human signs every action"
}

"""MatchTop · a system guard — on a breach it halts, it seals, it notifies.
Standard library only. It never acts further without a human signature."""

import json, time
from dataclasses import dataclass


@dataclass
class Breach:
    kind: str          # "cert_expiring" | "backup_failed" | "intrusion"
    host: str
    signed: bool = False   # stays False until a human says yes


def on_breach(b: Breach) -> dict:
    """Freeze the surface, seal the evidence, raise a hand. Nothing more."""
    seal = {"host": b.host, "kind": b.kind, "sealed_at": time.time()}
    notify(b)                                 # a human is told immediately
    return seal                               # halted and sealed, not yet acted on


def act(b: Breach):
    if not b.signed:
        raise PermissionError("no restart, scale-up or change ships without a signature")
    apply_fix(b)                               # only reachable after sign-off

"""MatchTop · the restore drill — proves a backup is really restorable.
It drills a shadow copy, never the live house, and writes down what it found."""

import csv, sys


def drill(backup, shadow_target) -> str:
    """Restore onto a shadow copy and verify it, on a schedule — not on faith."""
    restored = backup.restore_to(shadow_target)   # never touches the live host
    ok = restored.integrity_check()
    path = f"drill-{backup.id}.csv"
    with open(path, "w", newline="") as f:
        w = csv.writer(f)
        w.writerow(["backup_id", "taken_at", "restored_to", "verified"])
        w.writerow([backup.id, backup.taken_at, shadow_target, ok])
    return path                            # a record you can read, not a promise

What cannot be copied

Why a run ground beats a ground you must run yourself.

A hosting tool cannot run your systems — it hands the running back to you. A faceless service cannot give you the one engineer who watches it. And a backup no one has restored cannot be trusted when it matters. That is why there is no price list here: we look at what the ground must do, we measure it, and we quote what we measured.

Held in confidence

Before a line is written, how your systems and their data are kept. This part is not negotiable.