What we run

The whole voice, 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 speaks in your name on its own.

Measured, not claimed

How the voice is held — not invented growth figures.

The build — what drafts, what gates, what ships

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.

"""MatchTop · a content agent — it drafts in your voice, it never publishes on its own.
Standard library only. The agent proposes; a person signs."""

import json
from dataclasses import dataclass, field


@dataclass
class Draft:
    channel: str        # "post" | "campaign" | "reply"
    text: str
    voice: str           # which stored voice profile produced it
    signed: bool = False   # stays False until a human says yes


def load_voice(company: str) -> dict:
    """The voice profile is stored once and reused — not re-guessed per post."""
    with open(f"voices/{company}.json") as f:
        return json.load(f)


def draft_post(brief: str, company: str) -> Draft:
    voice = load_voice(company)
    text = compose(brief, tone=voice["tone"], rules=voice["must_avoid"])
    return Draft(channel="post", text=text, voice=voice["name"])   # signed=False

"""MatchTop · the publish gate — the one door every draft must pass through.
Nothing reaches a public channel without a human signature attached."""

class Unsigned(PermissionError):
    pass


def publish(draft, channel_api):
    """Refuses outright if the draft has not been signed off by a human."""
    if not draft.signed:
        raise Unsigned("nothing is published in your name on its own")
    return channel_api.send(draft.channel, draft.text)   # only reachable after sign-off


def sign(draft, signer: str):
    """The one action that turns a draft into something that may go out."""
    draft.signed = True
    draft.signer = signer                        # logged — who signed, not just that someone did
    return draft

"""MatchTop · the scheduler — queues only what a human already signed,
and releases it at the right local hour. No silent auto-posting."""

from datetime import datetime
from zoneinfo import ZoneInfo


def queue(draft, run_at: datetime, tz: str = "Europe/Zurich"):
    if not draft.signed:
        raise PermissionError("only signed drafts may be queued")
    return {"draft": draft, "run_at": run_at.astimezone(ZoneInfo(tz))}


def release_due(queued, now: datetime):
    """Only fires the ones whose signed, scheduled hour has arrived."""
    return [q for q in queued if q["run_at"] <= now]   # still signed drafts only

What cannot be copied

Why a run voice beats a feed you must fill yourself.

Generic AI spam cannot sound like you — it hands your name to a template. Auto-post cannot be trusted with your reputation. And an agency floor cannot give you the one hand that answers for it. That is why there is no price list here: we look at what the voice must say, we measure it, and we quote what we measured.

Held in confidence

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