Architecture
A pipeline of stages, a site of three layers, a protocol that travels
TITI moves a single prompt through an ordered workflow and emits a product whose structure is fixed by design rather than decorated after the fact.
- Stages
- Three layers
- Audit machine
- HAYAT
The pipeline as an ordered workflow
TITI is organized as a sequence of stages, each consuming the output of the one before it: Prompt, Research, Architecture, Design, Build, Test, Deploy. The order is the point. Research precedes architecture because the domain has to be understood before structure is chosen; architecture precedes design because the shape of the product constrains its surface; test precedes deploy because nothing ships that has not been checked.
The platform prefers inference to interrogation. From the single prompt it researches the domain and decides the architecture rather than asking the operator to specify it. The target is zero questions per project — not as a slogan but as a design pressure that pushes work upstream into Research, where it can be resolved from evidence instead of from a question.
This is a workflow description, not a catalogue of internal machinery. The stages above are the real contract between one step and the next; we do not claim hidden queues, handoff mechanisms, or retry behaviors beyond this ordered movement.
The three-layer anatomy
Every site TITI generates has the same three-layer anatomy. The marketing layer addresses human visitors. The science layer carries method, principles, and depth — pages like this one. The agent layer is machine-readable: files written for other software to read rather than for a person.
These layers are not styling choices applied at the end; they are the structure the Architecture stage commits to and the later stages fill in. A visitor and a program reading the same site are served by different layers of the same artifact, each shaped for its reader.
The separation matters because the three audiences have genuinely different needs. Decoupling them lets the marketing surface change without disturbing the machine contract, and lets the science layer explain mechanism without performing for either.
The agent layer and HAYAT inheritance
The agent layer publishes machine files. /agent.json describes the site and names its contact, which is the resident chat. /sot-map.json provides a structured map of the site and its source of truth. /.well-known/hayat-manifest.json is published at the well-known path where other software expects to find it.
HAYAT is the cross-site protocol these files implement. Every site the engine builds inherits it, which means a program encountering any TITI-built site can rely on the same files in the same places with the same meaning. Inheritance is what turns a single site's convention into something another system can depend on across many sites.
The protocol is a shared shape, not a promise about content. The files are published and available for a reader to consult; the structure is consistent because each site carries the same protocol forward.
The audit machine
Before deploy, a build passes through an audit machine that combines two kinds of judgment. The first is deterministic, machine-checkable gates: markup and structure validity, a check that no fabricated metrics have crept into the content, and render correctness across languages — including right-to-left scripts and CJK layouts.
The second is a cross-family taste judge that assesses qualities a deterministic gate cannot capture. The two are complementary: the gates catch what is mechanically wrong, the judge weighs what is merely poor.
The rule binding them is simple and strict. A build that fails any gate or any floor is refused. There is no partial pass — the audit is a condition on shipping, not a score appended to it.
The self-improvement loop, and what it is not
TITI builds TITI: the engine helps rebuild and improve itself. But this loop is human-supervised. A human reviews and approves each step. The recursion is real, the autonomy is not — the engine proposes and assists, a person decides.
We state the limits plainly. Full single-prompt, hands-off autonomy is the trajectory, not a finished capability. The resident-intelligence chat backend is not yet connected; the chat you see is an honest seam today, the interface present before the intelligence behind it is wired in. The economic terms — what subscriptions and tokens cost — are deliberately unset.
Naming these limits is part of the architecture, not an aside to it. A system that distinguishes what it does from what it intends can be trusted on the first because it is candid about the second.
Resident chat
Ask the architecture directly
Hi — I’m titi. Tell me what you’d like to build; a few words is enough.
I’ll turn it into a real, tested, deployed site.
Seam — backend not yet connected