01

Most of your code checks for what should never happen.

The check payments.py

def charge(order):  # ship it
    try:
        data = post(PAY, order).json()
    except Exception:
        return None  # eh, just retry
    if "status" in data:
        if data["status"] == "approved":
            return data["charge"]["id"]
        if data["status"] == "declined":
            return None  # also retry?
    return None  # who knows

# {"status": "approved", "id": "ch_9"}
# KeyError: 'charge'

Charged twice.

The type payments/model.py

class Approval(BaseModel):
    status: Approved
    charge: ChargeId = Field(alias="id")
class Decline(BaseModel):
    status: Declined
    codes:  DeclineCodes
class Outage(BaseModel):
    error:  StatedError
class Reply(RootModel[
    Approval | Decline | Outage
]):
    """Every answer they have."""

# {"status": "approved", "id": "ch_9"}
Reply.model_validate_json(raw)
# Approval(charge=ChargeId('ch_9'))

Charged once.

Architecture 2026

See a whole program built this way.

Each of those checks exists because a type allows more than your business does.

In most code:

  • Text can hold any string.
  • A number can be any amount.
  • An empty value can mean anything.

In Type Construction Architecture:

  • A status holds only your statuses.
  • An amount holds only what you charge.
  • Absence is a case with a name.

So a program that only builds these types has nothing left to check, and an incident has nothing to be.

Those types are the rules, declared once in their owner’s words, so a new hire, the product owner and you next year read what runs.

To an agent, those types are a world model of your business, so the same declarations that tell it what exists stop it from building anything else.

02

Every system you run has its own idea of your business.

Language 2026

In early release.

ONTOK, built with Type Construction Architecture, writes what your organization is once, as running code every system and agent works from.

The CRM, billing and support stop keeping separate customers for someone to reconcile by hand. The definition belongs to the organization, never to a vendor.

A fact enters only once what it rests on is proven, so what your people know becomes what every system understands.

03

Your organization runs on judgment nobody wrote down.

Book in progress 2026

Written in public, a chapter at a time.

Every organization runs twice: as its documents describe it, and as it actually works. An agent is handed the documents.

That difference is judgment your people supply unasked, and it can be found. Trace one case that mattered and ask the documents:

  1. Who determined the result?
  2. What information mattered?
  3. What condition triggered the decision?
  4. What authority governed it?
  5. What consequence followed?

Every gap is knowledge your organization has never written down. The book is the method for finding all of it.

Then the work can run on what your business knows.

Systems that understand the business carry its cases from start to finish, exceptions included, and the people who know it best decide what it should become.

Kyle J. Tobin, drawn in pencil

Kyle J. Tobin works on how organizations will now have to run: whole, explicit, and executable, from the authority at the top to the code underneath.

Correspondence contact@talco.dev