What we run

Four kinds of agent, put to work across your operation — each one proposing, never acting alone.

How it is controlled

The difference is not a flashy dashboard. It is the sign-off — and nothing acts on your behalf on its own.

Measured, not claimed

How the agents are held — not invented autonomy figures.

The build — what proposes, what gates, what logs

The agents are not the show; the sign-off is. Here is the real shape of it.
The code stays in English — the universal language of engineering.

"""MatchTop · an agent — it proposes, it never ships on its own.
Standard library only. The agent raises a hand; a person decides."""

from dataclasses import dataclass, field
from datetime import datetime


@dataclass
class Proposal:
    kind: str          # "restock" | "refund" | "reply" | "reconcile"
    detail: dict
    reason: str
    raised_at: datetime = field(default_factory=datetime.utcnow)
    signed: bool = False   # stays False until a human says yes


def watch_stock(store, floor=3):
    """Low stock is not an order. It is a proposal that waits for a signature."""
    for item in store.low_stock(below=floor):
        yield Proposal(
            kind="restock",
            detail={"sku": item.sku, "qty": item.reorder_qty},
            reason=f"{item.sku} at {item.stock}, below floor of {floor}",
        )

"""MatchTop · the sign-off gate — the one door every proposal must pass.
No action reaches the business side of the system unsigned."""

class PermissionError(Exception): pass


def apply(p: Proposal, signer: str | None = None):
    """Raises unless a human has signed. Nothing else gets this proposal through."""
    if not p.signed or signer is None:
        raise PermissionError("no action ships without a human signature")

    store.execute(p)                      # only reachable after sign-off
    log_signature(p, signer)              # every pass through this gate is recorded

"""MatchTop · the signature log — append-only, who signed what, when.
Nothing is edited after the fact; the record is the record."""

import csv
from pathlib import Path
from datetime import datetime

LOG = Path("signatures.csv")


def log_signature(p: Proposal, signer: str) -> None:
    """One line per signed action — auditable by anyone you point at this file."""
    is_new = not LOG.exists()
    with LOG.open("a", newline="") as f:
        w = csv.writer(f)
        if is_new:
            w.writerow(["raised_at", "kind", "reason", "signer", "signed_at"])
        w.writerow([p.raised_at, p.kind, p.reason, signer, datetime.utcnow()])
    return None                            # handed to the record, not to a black box

What cannot be copied

Why agents under sign-off beat agents that act on their own.

Autonomous AI cannot be trusted with your money — it acts first and explains later. A black box cannot be audited. And a faceless bot cannot answer for what it did. That is why there is no price list here: we look at what your operation needs run, we measure it, and we quote what we measured.

Held in confidence

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