ditzl.ai is a peer-to-peer and business network you swipe across. Move left and right between its panels - home, tickets, social, broadcast, eats, maps, photos, lessee and market - and up and down within each one.
There are no ads, ever. Public pages live on Cloudflare. Private things you choose to keep, like receipts, are encrypted on your own phone.
Every change to the platform is a hashed record on an append-only tree, sealed by a person. Anyone, human or AI agent, can check those records through ditzl's public doors: /.well-known/hcp and /.well-known/mcp.json.
ditzlmail.com is ditzl's mail for people. One passkey signs you in to both ditzl.ai and ditzlmail.com. A sign-in ends after 30 minutes without use.
Plainly, what is not built yet: mail is not end-to-end encrypted today. Mail bodies are still stored on ditzl's server. Encrypting mail so only your devices can read it is the next step for ditzlmail.
Watching is free. No one pays to watch a show, and looking around needs no account.
Broadcasters pay: $29.99 a month, which includes 10,000 viewer-minutes, then $2.00 for each extra 1,000 minutes. You subscribe at Stripe's checkout and can cancel any time. Your card stays with Stripe; ditzl keeps only a fingerprint of the email you pay with.
Correction (2026-10-31): we thought $9.99 a month for unlimited streaming was right. It was not, and it is retired. The correction is sealed on the public tree (kind record.correction).
The one-time building prices on ditzl.ai/billing still apply, and your first app, first page and 5 photos are free.
Open the show's link, or find shows on ditzl.ai/network. When the show is live, tap Watch and the show starts. Watching is free: no one pays to watch a show, and looking around needs no account.
A bio is a person's or a show's own page on social, at ditzl.ai/social/bio/your-name. It shows followers, likes and views counted on ditzl, and its link can be shared anywhere. Video uploads from a bio are coming.
A bio is made only with that person's own yes. Next, you will create your bio from your phone and seal it with your own passkey.
No. ditzl has no ads, ever, and sells no data. Who follows you or what you watch is never sold or shown to advertisers - there are none. Counts are public; your private things stay yours.
ditzl.ai/broadcast is where you ask to become a broadcaster: your own app on ditzl.ai for your shows, with live rooms, tickets and your own viewers. Your viewers belong to your app, not to ditzl.ai.
Every broadcaster pays the same plan: $29.99 a month, which includes 10,000 viewer-minutes, then $2.00 for each extra 1,000 minutes, with a card on file. Each show is made by its own broadcaster; no broadcaster works for or speaks for ditzl.ai.
ditzl.ai/podcast is retired and folds into ditzl.ai/broadcast: a podcast is a broadcast.
ditzl.ai/photos keeps the photos and videos you choose encrypted on your own devices. Each one is encrypted on the device with its own key, and ditzl's server gets only its fingerprint - not the picture, its name or its size. You sign in to use it.
For a second copy, approve your other device on your devices page and keep that page open on both: photos move encrypted, device to device, and the relay in between keeps nothing. If every device that holds a photo is lost or cleared, that photo is gone - no one else can open it, ditzl included. Keep iCloud for now: the recovery key is not built yet, and neither are public photos.
Spatial cartography is the process of verifying physical reality through human presence and translating that into precise, mathematical coordinates.
Spatial cartography creates a digital map that accurately reflects the real world.
Model Context Protocol (MCP) is the standardized mathematical connection bridge where an AI client dynamically connects to a lightweight server to discover and invoke tools using pure, lossless integers instead of heavy textual scripts.
Human Context Protocol (HCP) is the unyielding runtime framework that maps real-world human presence and physical field observations directly into decentralized, zero-drift spatial coordinates, ensuring that the machine layer can never hallucinate or misinterpret the ground truth of the pavement.
The slow visual layer built for human eyes is decoupled from the high-speed mathematical layer built for machine reasoning. The protocols don't write code — they match numbers.
Search Engine Optimization (SEO) is the legacy practice of formatting natural language text, markup scripts, and sitemaps so that traditional, centralized corporate search crawlers (like Google or Bing) can index and rank heavy HTML web pages for human consumption.
Model Context Protocol (MCP) is the decentralized open standard that allows advanced AI agents to connect directly to lightweight data layers to discover and execute functional tools natively using raw numbers instead of parsing visual layouts.
They are not the same thing — they operate on completely different layers of the internet. In this architecture you need both, but they are used as symmetrical variables on a single, unified edge template.
The modern web is split between humans using old search tools and automated machines executing agentic routines. One data footprint handles both concurrently, without writing separate platforms:
[ RAW D1 INTEGER ARRAY ]
/ \
/ \
[ THE VISUAL TEXT FILTER ] [ THE MATHEMATICAL API FILTER ]
(SEO) (MCP)
| |
Traditional Search Engines AI Agent Clients
(Google / Human Crawlers) (Claude / Dragnet)Centralized search engines still dictate how local humans navigate to businesses. If a contractor searches for wholesale aluminum, or a crew searches for a food truck, Google's crawling bots need a discrete URL path and structured metadata pointers to grant a domain ranking authority. SEO variables are used strictly as an edge-cached visual text filter, to capture traditional traffic and clear false-positive phishing flags.
AI agents do not care about font styles, layout grids, or marketing paragraphs. When an agent needs to pull an invoice tracker, update a pricing tier, or verify a geographic coordinate block, forcing it to download and scrape a heavy HTML page wastes thousands of tokens and introduces latency drift. MCP gives the machine an explicit, lightweight tool interface to ingest data cleanly via integer tuples like [Tenant, Market, Language].
You do not build two separate websites. When a legacy search bot knocks, the edge worker passes standard SEO sitemap variables and indexes cleanly. When an AI agent client knocks on the same endpoint, the worker inspects the request, skips HTML processing entirely, and opens the MCP gate — exposing the raw numbers and the Merkle root hashes that match them.
Both layers of the web are satisfied from one place: corporate SEO rules for public visibility, native MCP tools for the next generation of automated computing.
The ARRAY language is not a new software syntax or compiled framework. It is an architecture that completely replaces textual programming code (HTML, CSS, JSON-RPC, SQL) by mapping every asset, layout coordinate, language string, and system dependency to a fixed multi-dimensional grid of raw integers. It came about out on the pavement of the Albuquerque Rail Yards and the streets of the International District. It was forged through the real-world friction of watching standard web pages lag on job sites, seeing text-heavy databases drift out of sync, and watching a phone battery go completely black in a desert field while trying to load a massive corporate government map . You use ARRAY because regular coding tools are built for a perfect, fictional world with infinite battery life and endless server processing power. ARRAY is built for human survival .
Traditional web applications have ballooned into an unmanageable mess of heavy software layers. ARRAY permanently eliminates that bloat by replacing files with numbers:
The Problem of Code Bloat: Over six months, a simple 500-line routing script can easily swell into 10,000 lines of messy, hard-coded string logic just to handle different variations of languages, user screens, and business markets. ARRAY fixes this by reducing variations to a single mathematical formula. An layout grid isn't a complex script; it is a compact parameter tuple: [TenantID, MarketID, LanguageID, ViewID].
The Problem of Language Drift: Traditional sites use heavy translation plugins that break mobile browsers and sound completely clinical. ARRAY fixes this by mapping local spoken vocabulary straight to integer rows. Your field-verified terms (like "Pisos de Madera Recuperada Premium" or "Aluminios y Manufactura Whittaker") are hard-baked directly into a static lookup matrix, loading instantly in the exact native tongue spoken by your crews on the job site.
The Problem of Screen-Resolution Overhead: Developers spend thousands of hours writing messy CSS media queries to make websites look right on different phones and monitors. ARRAY fixes this through single-step machine extrapolation. Your agent (Transit) takes raw canvas RGB block coordinates and instantly calculates the perfect rendering positions for 17 distinct monitor resolutions in a single mathematical pass, changing the layout cell-by-cell down at the pixel layer.
| Metric | Regular Coding Tools (The Legacy Web) | The ARRAY Language (The Edge Mesh) |
|---|---|---|
| Execution Size | 10,000+ lines of bloated, heavy framework code. | Strict, lightweight worker under 500 lines of stateless logic. |
| Data Medium | Heavy, vulnerable, human-readable text strings. | Sterile, unbendable, cryptographically signed integer matrices. |
| Security Layer | Complex firewalls vulnerable to prompt injection and scrapers. | Unassailable three-way Merkle root handshake locked to the human Apex. |
| Mobile Performance | Heavy page weights that drain phone batteries in low-coverage zones. | 2-millisecond sub-hydration payloads that run on 1% battery in a field. |
You choose ARRAY because regular coding tools force you to serve the machine's architecture. With ARRAY, the machine is forced to serve the absolute, unyielding truth of human presence on the pavement.
The engine does not change. What changes is how people assemble it. There are two kinds of user, and neither has to become the other.
The Action: These users walk the pavement, trace raw RGB codes via Transit, capture local landmark color profiles (like the Tingley Park stucco), or design dynamic moving elements like the dancing chile spinners and roadrunner status bars.
The Ledger Math: They mint these custom assets as pristine, new structural blocks carrying an absolute, unique integer code directly onto the Cloudflare D1 world_tree table.
The Action: These users have zero interest in looking at terminal code, editing configurations, or rendering raw graphics.
The frictionless UI: They open their mobile layout canvas, pull up the revolving library of community-minted assets, and literally drag and drop the interchangeable blocks into position like digital Legos. They can snap a regional Barelas transit font block right next to a custom food-truck menu array with zero technical friction.
Because our canon is unyielding, there are no messy, slow, overlapping layout scripts running when blocks are dragged around a screen:
Moving a block into position on a phone does not write heavy HTML or CSS files. It simply updates a tiny, compressed multi-dimensional parameter tuple: [Block_ID, Canvas_X, Canvas_Y].
The second a user lets go of a block, Transit instantly extrapolates its positioning across 17 distinct monitor resolutions in a single pass—ensuring the canvas shifts fluidly down to the exact pixel layer without a millisecond of lag.
Creating a block from scratch is where the paid tool sits. Transit turns an upload into glyphs — you hand it a photo and it produces the block assets from it. That is a paid AI tool, charged to the tenant who uses it, the same way an image upload is.
Reusing a block that already exists is free. There is no gate on the block library and no payment between users.
You have turned the digital parliament into a completely fluid, self-generating playground. Hardcore cryptographic logic handles the security perimeter silently in the background, while the human user experiences nothing but frictionless, tactile design freedom on their screen.
ditzl builds and hosts a page for a place of business. The page is not a document somebody wrote and uploaded. It is assembled at request time out of rows in a database, each row naming a block of code and the data that fills it. Change a row and the page changes. There is no build step and nothing is cached between you and the database.
Every decision that shapes this platform is written to an append-only log called the tree, one entry per fact. An entry is called a leaf. Leaves are never edited and never deleted - a leaf that turns out to be wrong is superseded by a later leaf that says so and points back at it, so the mistake and the correction are both permanently readable.
You can read any of it without an account at /.well-known/tree.
Yes, and that is the point of it. Each leaf is addressed by a hash of its own contents: sha256(serialize(canonicalJSON(blob)) + parent). Fetch a leaf at /.well-known/tree?hash=<hash>, recompute that digest over what came back, and compare. If the two do not match, the record is lying to you, and you found that out using nothing but the public response and a sha256 implementation.
The same applies to the code that renders a page. Every block carries a canon hash over its own template. The full vocabulary of blocks is published at /.well-known/blocks.
Some facts are attested by a person rather than measured by a machine. When that happens, the statement is signed through Google, and the signature is bound to the exact words attested - the nonce Google signs is a digest of the statement itself, and of the coordinates too when a location is part of the claim. A signature therefore cannot be lifted off one sentence and reattached to another, or off one place and dropped on another.
What it proves is narrow and worth stating plainly: that a specific Google account asserted those specific words at that time. It does not prove the words are true.
Nothing on this platform publishes itself. A page is built in an unsealed state, tuned, and only becomes public when a human marks it so - and that is true of pages the operator builds for himself, which is where the rule came from.
Writes to the tree refuse anonymous callers. You can verify that refusal yourself: POST to /api/tree/leaf or /api/tree/attest with no credentials and you will get a 401.
Some pages on this platform describe places that never asked for one. Where that is so, the page is built from public information and is marked as a recommendation rather than as anything the business itself said.
To be direct about the current state rather than describe an intention: the mechanism for a business to record its own consent exists in the schema and is not yet wired to anything a business can press. Until it is, no page here should be read as endorsed by its subject. If a page describes your business and you want it changed or taken down, write to the address in the footer and it will be done.