Dira — The Principles of Ansai Technologies

Dira is the principles collection: the written philosophy behind everything Ansai builds. Entries are added as the buildout teaches us things. This is entry 01.

Entry 01 — Digital Infrastructure (2026-09-24)

The thesis

Nothing we build is "just a website" or "just an app." Every artifact we ship — a website, an app, a school system — is infrastructure: a node in the client's environment that both emits data and ingests data. Customers come through it. Staff work through it. AI crawlers come through it. A website is not a brochure; it is a working asset that gives data out and pulls data in, and in the age of AI it can be monetized directly (Cloudflare is already building the rails for charging AI crawlers for access — see §7).

The goal: companies that utilize every single data point, every data generator in their environment — clients, internal operations, the website itself. Nothing leaks. Everything compounds.

The company stack

For every company we work with, the build follows one pipeline:

1. Capture — find every data generator in the environment (customers, staff, the website, the app, events, records).
2. Clean & organize — the data is cleaned and structured until it is trustworthy.
3. Store — it lands in a proper database, owned by the company.
4. Internal tools — we build the tools the company uses to track its data and its work.
5. Mini agents — every person in the company gets a personal agent that helps them with their work, day to day.
6. The mother agent — one overseeing agent for the entire company, with the full picture, coordinating the mini agents.

This is where personal agents scale into organizations: the mother agent holds the company's memory and direction; the mini agents do the work alongside each human.

The human part

We do not just install technology. We restructure how people work and think: how employees approach problems, how they optimize, how they maximize. The technology without the thinking is wasted. Teaching the thinking is part of the job.

The individual

The same philosophy serves individuals, not just companies. A person gets a personal agent that documents their life and works for them — and the most intimate parts of that data stay theirs through private micro-clouds: small, owned infrastructure where a person's data can live without fear of takeover. Ownership of data is the trust moat.

Everything becomes intelligent

No product stays "normal." A school management system becomes intelligent school operations. Agriculture — food, the most fundamental pillar — becomes more efficient through AI. Every sector we touch gets the same treatment: capture its data, organize it, make it intelligent.

The seam

AI and AGI will phase out jobs. They will also introduce many more. Ansai is built for that seam: the company that exists where the old work disappears and the new work appears — building the infrastructure, the agents, and the thinking for both companies and individuals.

How the builders do it

What the frontier AI labs, the engineering writers, and the open-source world have documented that bears on this philosophy. Researched September 2026.

1. The labs

Anthropic — the best-documented playbook. Their engineering writing ("Building Effective Agents") draws the line between workflows (LLMs on fixed code paths) and agents (LLMs directing their own process), and prescribes simplicity first: start with the simplest thing that works, add complexity only when it pays. Five composable patterns: prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer. Their multi-agent research system — an Opus 4 lead agent planning and spawning parallel Sonnet 4 subagents — beat a single agent by 90.2% on internal evals, at roughly 15× the token cost: multi-agent is for high-value, breadth-first work, not everything.

Most directly relevant to our stack is Anthropic's writing on human-agent teams: agents with their own memory, skills, and credentials living where work happens. Four lessons we should steal outright:

• Work in public: "for an agent, if it's not written down and accessible, it doesn't exist." Agents become primary consumers of company documentation.
• Defined roles: one roster for humans and agents; skill files define agent roles so they can be stood up repeatedly across the company. Without clear roles, people run "fleets of personal AIs on the side," fracturing context — the exact failure our mother-agent design prevents.
• North star: humans set an ambitious written goal; agents may proactively suggest work toward it.
• Trust over time: autonomy in proportion to demonstrated reliability; Doer-Verifier harnesses (one agent does, another checks); "treat human attention as the scarce resource."

Meta — infrastructure rebuilt for agents. Agentic queries hitting Meta's data systems grew 30× in a single half; their infrastructure VP says they have "maybe 20 months to rebuild for AI agents." Meta needed 50+ specialized agents and months of iteration to generate persistent structured context for its codebases — "the context layer isn't optional. It's infrastructure." This is our thesis stated by a hyperscaler: infrastructure must serve agents as primary consumers, not humans.

OpenAI — harness engineering. The arc runs Swarm (experimental) → Agents SDK (agents, handoffs, guardrails, sessions, tracing) → "harness engineering": an AGENTS.md living constraint file read every session, repo-local docs, layered architecture enforced by linters, ephemeral observability. (One secondary account claims ~1M lines of code in 5 months with 3 engineers — unverified, treat as directional.)

xAI — councils, not single agents. Grok 4.20 reportedly ships a four-agent council natively inside the model response — lead orchestration, research/fact-check, logical verification, creative synthesis — with adversarial consensus cutting hallucinations from ~12% to 4.2%. (Secondary sources; not confirmed on xAI's official blog.) The pattern matches everyone else: orchestrator + parallel specialized workers, with verification built in.

2. The closest formal philosophies

No single canonical "everything is infrastructure" manifesto exists — our exact formulation appears to be original. The nearest formal documents:

• Elsewhen, "The Agentic Enterprise" (2025): every company becomes a modular agentic enterprise; agents share intelligence and memory; "an agent's effectiveness is directly proportional to the quality and accessibility of the data it uses." This is the closest match to our pipeline: data foundation first, agents second.
• AWS, "Data Flywheel" ebook: the canonical data-flywheel treatment — self-reinforcing loops where data initiatives feed each other.
• Runner AI's "Fly" (Sep 2026): a shipped central intelligence that researches 24/7 while founders approve what matters, with 10+ specialized agents executing — the closest shipped "mother agent" product.
• Corvera (YC W2026): a data-infrastructure layer unifying fragmented operational data, exposed to agents via MCP; agents execute, humans review. The "data layer → agent layer" pattern in production.

3. The writers (reading list)

• Steve Yegge — "The Anthropic Hive Mind" (Feb 2026): campfire development, flattened titles, radical transparency, "speed is not the goal; it's the symptom" of optimizing the cost of learning.
• Addy Osmani (Google Cloud AI) — the verification school: "AI's 70% Problem" (AI does ~70% of scaffolding; the remaining 30% is as time-consuming as ever), "Comprehension Debt" (AI-assisted developers scored 17% lower on comprehension quizzes), "The Factory Model" ("Generation is not the bottleneck anymore. Verification is.").
• Austin Xu — field report from actually building an AI-native org: spec-driven development, agents for support/triage, AI-assisted management.
• Chier Hu — "Rebuilding a Company Around AI": one company's 500→29 employee rebuild (single narrative, uncorroborated — read for the sequence, not the numbers): put all work online, standardize all processes, let AI assume repetitive labor.
• Itay Shmool — "The AI-Native Organization": flat orgs, leads as hands-on builders, decision latency from days to hours.
• Johnpaul Nwagwu — "Treat agents like employees: with a role, a manager, KPIs, and a path to promotion."
• Alvar Laigna — "The AI-Ready Enterprise": the practical sequence — document one API, add AGENTS.md, give agents their own identity and scoped credentials, wrap one workflow with MCP, gate irreversible actions with human approval.
• Tim O'Reilly — every automation leap changes how we program, not why we need skilled programmers.
• Gergely Orosz / The Pragmatic Engineer — the engineering-leadership newsletter; recent work on how engineers collaborate with AI agents, why human judgment still matters, and "capability gaslighting" (models impressing users, then failing the same task the next day).
• Petar Ivanov — production AI agents and software architecture; "5 Resilience Patterns for AI Agents" (Sep 2026): retry the step not the run, idempotent tools, checkpoint/resume, fall back across failure domains, bound the loop and hand to a human. Directly applicable to our agent factory (see §4).
• ByteByteGo — system design fundamentals; recent deep explainer on model customization (LoRA/QLoRA) — relevant when we need specialized models rather than bigger prompts.

4. The practical playbook (concrete patterns)

• Evals in three layers: unit tests (deterministic parts), trajectory evals (was the path good), outcome evals (was the goal achieved). Start with tracing + outcome evals; add guardrails as stakes rise.
• Cost-per-success as the key metric — alongside success rate, latency, and tool-call frequency.
• Human-in-the-loop for irreversible actions. Reversible internal actions can run autonomously; external irreversible ones need approval.
• Least-privilege agent identities — agents get their own scoped, short-lived credentials, never a human's keys.
• Doer-Verifier harnesses — one agent does, another checks; every agent task needs a verification method.
• AGENTS.md constraint files — living repo-level instructions the agent reads every session, updated whenever something fails.
• Production resilience (Petar Ivanov's five patterns): at 98% reliability per call, 1 in 3 runs of 20 steps hits a failure — so retry the step, not the run; give every tool that writes an idempotency key built from stable IDs; checkpoint after every step so a crash means resume, not restart; fall back across failure domains (same model on another cloud before switching models); bound every loop on steps, tokens, and wall-clock time, then hand the saved state to a human.

5. The open-source stack for building it

• Orchestration: LangGraph (durable state machines, checkpointing — best for long-running auditable work), CrewAI (fast, team-like role-based crews), AutoGen (research pipelines), Hugging Face smolagents (minimal, code-first — agents act by writing Python).
• Connective tissue: MCP (Model Context Protocol) — how an agent reaches tools and data, "USB-C for AI"; A2A (Agent2Agent) — how independent agents delegate to each other, the natural protocol for a mother-agent → mini-agent hierarchy; Agent Skills (SKILL.md) — packaging company knowledge as reusable agent capabilities; x402 — HTTP-native micropayments so agents can pay for data access programmatically.
• Personal-agent reference: OpenClaw (MIT, local-first) — runs on your own machine, reachable via WhatsApp/Telegram, memory and skills as local files you own. The closest open-source realization of "personal agent with private data ownership." Run it isolated, scope credentials tightly, vet third-party skills.
• Recommended synthesis: LangGraph or CrewAI for orchestration + MCP for tool/data access + A2A for the mother-agent hierarchy + SKILL.md for company knowledge + evals via Langfuse/Phoenix with Doer-Verifier harnesses.

6. The website as a revenue-generating asset

Cloudflare is building the economic rails for our thesis. Pay Per Crawl (announced Jul 2025, still in closed beta as of Sep 2026) revives HTTP 402 so publishers can charge AI crawlers per request — allow, charge, or block per crawler, with Cloudflare as merchant of record. In Jul 2026 Cloudflare shifted the framing from pay-per-crawl to pay-per-answer — compensation tied to citations in AI-generated answers — and is building a Monetization Gateway for charging agents for pages, datasets, APIs, and MCP tools, settled in stablecoins over x402. Context: bots were 57.4% of web traffic by Jun 2026. The direction is unambiguous: in an agent-mediated economy, a website is a data asset that agents pay to access. (Gateway pricing and general availability are undisclosed.)

What is original here

The pieces exist in the wild — Anthropic's agent teams, Meta's agent-first infrastructure, Cloudflare's crawler economics, the open-source agent stack. What we did not find is anyone stating the whole synthesis: every artifact is infrastructure; every data generator is captured; every company gets a mother agent over per-person mini agents; every individual gets a personal agent on data they own; and the delivery includes restructuring how humans think. That synthesis is ours. This document is its first written form.

Sources: full research report with 53 cited sources at ~/workspace/research_notes/agent-first-digital-infrastructure-20260924-1130/report.md.

Entry 02 — The Builders' Playbook (2026-09-24)

The "how" companion to Entry 01's "what/why": what the best engineering writers agree on (Orosz, Ivanov, ByteByteGo), the AI data startup money trail (Scale/Meta, Databricks, Snorkel, Temporal), how the three developer platforms (Claude, Gemini, Meta/WhatsApp) integrate into our stack, the Africa-first building playbook, seven possible directions, and a sequenced integration roadmap.

Full entry: dira-02-builders-playbook.md. Research behind it: ~/workspace/research_notes/engineering-writers-ai-theses-20260924-1138/report.md. Presented as a page: the "AI-Native Infrastructure Research" artifact.