Glossary
The words I use, and what I mean by them.
Proprietary
- Agent Redwood
My twelve-part design interview for any AI agent: name the twelve components, score each one for importance, then build to the scores.
Agent Redwood is the design ritual I run before building an agent. It covers twelve components: personality, planning, mission, constraints, memory, evaluation, tools, awareness, reward model, metadata, strategy and integrations. Each gets a 1-to-5 score for how much it matters to this agent. High scores get real engineering and low scores get the minimum that works, so the agent is exactly as complex as its job. In one session it cut an integration a team wanted before anything was built.
- Looikos
My portfolio of brands that all run on one shared set of tools, data and AI agents, each researched across finance, software and service.
Looikos is my name for the whole portfolio: dozens of brands across agencies, content, infrastructure and finance, each built on the same shared tools, data platform and AI agents. Every brand gets researched in depth from three angles: finance, software and service. At scale, the data from running all of them becomes the material the system learns from to build the next one, which is why I call where it's heading a simulation compiler.
- WikiDesignCo
My data-platform lab: the knowledge platform holding the metagraph every other brand reads from, also rented to clients on a flat retainer.
WikiDesignCo is the internal lab where I build the data platform under every Looikos brand: the metagraph, the date-stamped fact store and the content compiler. Every brand reads from it, and it's the public home for the research these systems produce. I also rent the same capability to operators as Forward Deployed AI Engineering on a flat monthly retainer, so they don't have to make an expensive two-engineer hire.
- AndyDataBot
The AI assistant on andydataguy.com. It answers from my 5-million-word personal corpus and shows where each answer came from.
AndyDataBot is the chat agent that rides along on every page of andydataguy.com. It's a retrieval-plus-agent system, more than a chat widget: it answers from the corpus of my own writing and notes, shows the sources behind each answer, and keeps the conversation as you move between pages. It's part of the proof that the site runs the systems it describes.
- ContentFactory
My live content platform, paid for by its first client, an equipment dealership: one knowledge corpus feeding every channel its buyers read.
ContentFactory is the first live instance of my content systems, paid for by its first client, a heavy-equipment dealership. One ingested knowledge corpus feeds the channels that dealership's buyers read. It's the working stress test for ideas that Constellation Media generalizes, and WikiDesignCo is its second version.
- FreelanceBuddy
My AI-assisted Upwork workspace: an agent drafts proposals for me to review, and after a hire it becomes mission control for that client.
FreelanceBuddy is my internal tool for winning and running freelance work. I paste in a job and my notes, an AI agent drafts the proposal artifacts, and I review and send. After a hire it tracks that client. It's built to handle 100 to 250 quality applications a month, and it's the first live testing ground for Hyperrelevance Cartography, because every application is a probe that gets an answer.
- Scatter Model
A planned Looikos product: define a domain once as typed objects, and generate the database, backend, frontend types and forms from that one model.
Scatter Model takes my habit of treating Pydantic models as the intermediate representation and makes it a product. You define a domain once as typed objects, shape and explore it visually the way you'd build a role-playing game world, and agents update it as you talk. That one model then projects into database schemas, backend and frontend types, forms and configs. It's concept-stage, and it's the data-modelling primitive for the whole portfolio.
- SuperHarness
My brand for engineering the systems around AI agents: I teach the discipline, release open-source plugins, and sell custom buildouts.
SuperHarness is the Looikos brand for harness engineering and the renamed successor to Symphony AGI. Under it I teach how to build the scaffolding that runs AI agents, release stress-tested open-source plugins, and sell multi-five-figure buildouts to organizations whose agent ambitions have outgrown their duct tape. Agent Redwood is its design layer.
- Constellation Media
The Looikos content engine: it owns every content pipeline and produces the social and editorial content for every brand and customer.
Constellation Media is the content-production brand for the whole Looikos portfolio. It owns the content lifecycle, from world modelling and character design through storyboarding, generation, editing, scheduling, analytics and research, on top of WikiDesignCo. ContentFactory is the first live instance proving it out, and Social Storyboard is the client-facing agency that sells the service.
- Harness V2
The second version of my shared agent framework, giving every Looikos brand the same councils of agents, observability, data tiers and MCP access.
Harness V2 is the shared agent framework the Looikos brands build on. It supplies the agentic-council pattern, observability, medallion data tiers and an MCP interface, so a brand like Quant Scientist is mostly that framework pointed at a new domain. Its development continues under the SuperHarness name.
- Story Factory
A planned Looikos brand for documents at industrial scale: hundreds of templates that agents fill dozens at a time while a person approves.
Story Factory is the document-generation primitive of the Looikos portfolio. It holds hundreds of report, document and form templates with typed slots, and agents fill them dozens at a time with grounded, cited content while a person steers through questionnaires and approval checkpoints. I call it Mad Libs on steroids. It's concept-stage.
- Symphony AGI
The earlier name for my agent system and the brand built on it. SuperHarness has since replaced it as the brand.
Symphony AGI was the name of my agent harness, the system the Looikos software runs on and the apparatus every brand was conducted by. As a brand it was framed as the thing you run on. SuperHarness superseded it, reframed as the thing you learn and hire, and older decks still use the Symphony AGI name.
- Wardley Swarm
A planned Looikos brand where AI agents build an evidence-backed strategic map of a situation and simulate moves across it.
Wardley Swarm is a strategy station. AI agents build a map of a situation, like a chessboard showing where the pieces are and how they're evolving, run brainstorms and simulations across it, and ground every element in evidence. It weaves together Wardley mapping, promise theory, game theory, Bayesian reasoning, Powell's policy classes and Convergence Flow. It's concept-stage, and its method already runs internally as the value rubric.
Coined
- Attention Engineering
My name for the craft of earning and keeping an audience's attention, aimed at deep relationships with readers over cheap engagement.
Attention Engineering is one of the five service categories on my wiki, covering media, distribution and the relationship with an audience. At the depth I write about it, the job is pulling exchanges out of projection mode, where the creator flatters and the audience feels without acting, and into actualization mode, where both sides pay a cost and the reader changes something. Standard Model of Effective Media is its framework essay.
- cycle of suffering
The loop most people walk: pain, a new fear, avoidance, a bad outcome, shame, denial, a blind spot, then more pain.
The cycle of suffering is the Problem half of PST. Pain arrives and installs a new fear. The fear drives avoidance, which produces a bad outcome. The outcome produces shame, which gets buried under denial and blame. Refusing accountability opens a blind spot, which produces the next bad move and more pain. I treat it as engineering data. Most content has to meet people here, because most people spend most of their time in it.
- hyperrelevance
Knowing one group of people so well, and so currently, that what you make fits them because it was made for them.
Hyperrelevance is what attention compounds into when you point it at one specific group of people for long enough. You know them so well and so currently that what you make fits them because it was made for them. It grows out of a correction loop: every probe into a market brings back evidence, the map updates, and the next probe gets sharper, without anyone pretending the uncertainty has gone away.
- Intelligence Engineering
Turning raw information into systems that change real decisions. Information only counts as intelligence once it changes what an operator does.
Intelligence engineering is my discipline for turning raw signal into decisions you can defend. Information becomes intelligence at the moment it changes a decision an operator was about to make; before that it's overhead. The work starts at the decision and designs backward to the smallest pipeline that changes it. Its three commitments: diagnose the pain first, design the reward function as carefully as the algorithm, and verify with evidence from the calendar, since a dashboard can mislead indefinitely.
- Lexicon of Pain
A library of the exact words buyers use to describe their problem, collected verbatim from reviews, forums, calls and support tickets.
The Lexicon of Pain is a structured corpus of the actual words your best buyers use for the problem you solve, the alternatives they reject and the future they want. I collect it verbatim from one-star reviews, forums, support tickets and sales calls, sort it by frequency and emotional weight, and read it back to the buyer in the copy until they feel seen.
- Mirror Ocean
My image for the attention economy: a platform that hands back a perfect copy of whatever you give it, with no self underneath.
In an Exurb1a video, a stranded scientist writes 'Hello' in the sand and the ocean returns a perfect copy, every time, with nothing behind it. That ocean is my picture of the modern feed: enormous, eager to please, and unable to give you anything that didn't come from you. Mirror Ocean work tells an audience what it already thinks. My essay is about building the deeper relationship.
- People · Product · Process
My nine-stage diagnostic: find which layer a business problem lives on, people, product or process, before spending a dollar fixing it.
PPP splits any business problem into three layers and nine stages. People (Problem, Future, Transformation) diagnoses the customer before anything gets sold. Product (Benefits, Message, Offer) packages the change they want. Process (Qualify, Sell, Fulfil) is the machine that carries a stranger across. Each phase feeds the next, so running them out of order breaks quietly. The discipline is naming which stage you're in.
- PST
Problem, Story, Transformation: my model for understanding a customer well enough to convert and serve them, far below demographics.
PST models the world a person lives in, finds where they're stuck in their cycle of suffering, and offers a way across to the cycle of growth. Problem names the station of suffering and the fears driving it. Story reconstructs the belief structure that keeps the loop running. Transformation designs the path across, calibrated as a crossable bridge. Every Looikos brand deck runs it on five or more personas.
- Standard Model of Effective Media
My model of why some media lands: a safe-looking outer layer that gets past the reader's guard, carrying something true underneath.
The name borrows from physics, where the Standard Model composes a few particles and forces into every measured interaction; mine is an attempt at the same for media. It treats media as two layers: a turbulent surface that has to satisfy distribution (the format, the hook, the first three seconds) and a laminar depth that carries the true thing. The innocent thing is the door, and the true thing waits behind it.
- Vector Engineering
Shaping what an AI system draws on when it answers, so questions about your business get answered from your real material.
When a retrieval tool answers, it's telling you about the slice of material it reached, nothing more. Vector engineering is the work of shaping that material, both the documents your people read and the numeric coordinates they never will. It means getting facts, relationships and their dates into a shape where a question can be answered and not guessed, and keeping that map so it doesn't vanish when somebody quits.
- Voice Compiler
The second machine after the content compiler: it makes approved content sound like one business talking to its own customers on one channel.
Where the content compiler decides what a piece says, a voice compiler decides whose mouth it comes out of. It takes content that already earns its place and fits it to one client, one audience and one channel, using a written profile of how that client talks. My test: if an agency's ten chiropractor websites read alike, the voice compiler did nothing. Both machines stand on a shared list of minimums every sentence has to meet.
- actualization mode
The mode where audience and creator both pay a cost: the reader strives, the creator acts as a bridge, and something changes.
In actualization mode the audience is a striver, the creator is a bridge, and both sides pay a cost. The work asks the reader to spend effort, and the reader comes out different. Attention engineering, as I practice it, pulls exchanges from projection mode toward this one, even at some cost to short-term reach.
- Beggar
My name for the operator who takes every client, because an empty calendar feels more dangerous than a bad fit.
The Beggar takes every client, quotes whatever number the prospect breathes near, and keeps onboarding people whose briefs read like riddles. It's operating from scarcity, which produces more scarcity. Plenty of operators in the $5K to $25K monthly retainer market run this identity without naming it. The Velvet Rope is the way out, and the Chooser is who you become once it runs.
- bounded existential pressure
Discomfort a creator applies on purpose, sized so the reader can bear it, to pull them out of comfortable echo and toward change.
The deepest audience relationships come from inflicting bounded existential pressure in place of giving people what they want. The creator makes the reader face something real, like the scale of what happens on the planet in a single day, and sizes the dose so the reader can get across. It's what moves an audience from projection mode into actualization mode.
- Chooser
The Beggar's opposite: an operator whose qualification system lets them pick their clients.
The Chooser reads 'you can help anyone, but you can't help everyone well' as an instruction and asks how the system gets built. Bad-fit prospects get a graceful exit and a redirect. You don't decide to be the Chooser; you become one as the output of running the Velvet Rope, in that order.
- cycle of growth
The upward loop that replaces fear when pain hits: truth, responsibility, healing and forgiveness, with courage as the hinge.
The cycle of growth is the Transformation side of PST, the alternative to installing a new fear when pain arrives. Its hinge is courage. It loops upward through truth (which you go out and find), responsibility (owning your reaction), healing (which hurts) and forgiveness (letting go of the old verdict), and forgiveness opens new truths that start the loop again.
- Disconnection
My name for a feature wired through some layers and missing from others, or one fact kept in two places that drift apart.
The Disconnection is the build failure I watch for most: something works through some layers but not all, so a customer falls through the seam, or the same fact lives in two copies that slowly disagree. My rule against it: each capability has one canonical home, and everything else references that home and keeps no copy.
- Five-Layer Drill
Questioning down through the layers beneath a client's stated problem until reaching the one they'd never have volunteered.
A founder arrives naming a surface problem: 'I need more leads,' or 'I want to raise a round.' The Five-Layer Drill keeps asking what sits underneath until it reaches Layer 5, the one the client wouldn't have volunteered: the cap-table mistake, the person who'll be embarrassed by a rebuild, the number they're afraid to look at. An audit that doesn't reach Layer 5 is forensic theater.
- giga-agency
An agency producing hyper-targeted media for hyper-specific niches at machine cost with human credibility, limited mainly by compute.
The giga-agency is what the content compiler makes possible: hyper-targeted media for hyper-specific niches, produced at machine cost with human credibility, scaled across every channel at once and limited by one input, how much compute you can buy. The compiler stays private, like a quant fund's models, and the agency's output is what gets sold.
- Heroic Failure
A founder working 80-hour weeks and approving everything personally. It looks like commitment, and it signals a broken operating system.
Heroic failure is the pattern where the founder works 80 hours a week, approves every invoice, onboards every client and runs support in the evenings. From outside it looks committed and successful. In my audits it's the loudest signal of a broken operating system, and the most reliable sign that the underlying problem sits upstream of where everyone is looking.
- Hyperrelevance Cartography
Mapping a market by probing it, recording what comes back, and updating the map before the next probe, the way a bat echolocates.
Hyperrelevance Cartography applies echolocation to markets, audiences and decisions. You send a probe (an interview, an ad, a proposal, a pricing page), record what comes back, silence included, adjust how much confidence the map deserves, and pick the next probe. The map stays provisional on purpose. A cartographer keeps a changing situation legible for a decision maker, tracking when each claim was true and what changed it.
- innocent thing
The safe-looking outer layer of a piece of media, like a flower, a rhyme or a specific detail, that lowers the reader's guard.
In my Standard Model, the innocent thing is the door a reader walks through with their guard down. Its surface signals safety, or signals that the person behind it paid attention and wants nothing. Once the guard drops, the true thing behind it can land. A flower, a counting rhyme and a strip of tape can each play the part.
- nine rungs
My operating hierarchy: Mission, Objective, Initiative, Project, Task, Action, Decision, Data and Event, with Purpose above them as the rails.
The nine rungs are how I align any piece of work, from the mission down to the single event that happened. Every artifact carries all nine, so drift between people, agents and layers shows up early. In my metagraph the rungs are node types, which makes the hierarchy something you can navigate as data.
- projection mode
The mode where an audience meets its own echo: the creator flatters, the audience feels something and changes nothing.
Most human exchange runs in one of two modes. In projection mode the audience is an echo and the creator is a flatterer, and the exchange produces feeling without action. Much of the attention economy is built to keep people there. Its opposite is actualization mode.
- Pydantic-as-IR
My practice of using Pydantic data models as the one typed source of truth that every database, API and interface is generated from.
Pydantic-as-IR means one typed Pydantic model defines each kind of thing in the business, and that single definition projects into a database schema, backend types, TypeScript and Zod types, forms and configs. Change it once and every layer follows, so copies can't drift apart. It's the discipline behind my content compiler and the product idea behind Scatter Model.
- Shape of Data
The claim behind my three-part series: the shape you store data in decides which questions you can ever ask of it.
The Shape of Data is a three-part series. Part one argues that the questions a body of data can answer are fixed when it's stored: a checkout that never recorded which click led to an order can never tell you which campaign made the money. Part two walks the five shapes data takes and what each is bad at. Part three covers time and provenance, which can't be added later.
- simulation compiler
My best name for where Looikos is heading: a system that compiles a modeled market into the agent-run systems that operate inside it.
Compilers turn source code into machine instructions. A simulation compiler points the same idea at a new input: the lived structure of a market, audience or domain, compiled into the agent-native systems that work inside it. Looikos becomes one emergently, because at scale the data, content and traffic from dozens of brands become the corpus it learns from. The concept is early, and the name is my closest handle for it.
- Space Crystals
My plain name for empty space that splits light near a magnetar, used as an instrument for reading hidden structure in a corpus or market.
Around a magnetar, a dead star with an extreme magnetic field, empty space behaves like a crystal and splits the light crossing it. Physicists call it vacuum birefringence; I call it space crystals. The lesson I take is that the medium a signal crosses is never empty. A question crosses a corpus and an offer crosses a market, and that medium has a structure of its own that shapes what comes back.
- State Machine Everything
My practice of modelling every workflow as a graph of named steps, conditional handoffs and one owner for each piece of state.
State Machine Everything is how I run any operating system: as a directed graph with named nodes, edges that carry conditions, and one state object where every key has a declared owner. Work moves from review to merge because a named condition evaluated true, and when it's false the work goes somewhere else, usually backward. Defects that used to hide in handoffs get caught, because the transitions now have owners.
- The Floor
My shared-floor operating model: small pods where knowledge lives in a live room everyone can overhear, replacing a personal assistant per rep.
A dedicated assistant per salesperson turns into a garden: knowledge piles up around one person and walks out when they leave. The Floor replaces it with a pod of three to five people, eight at most, in a shared chat room with rotating senior coverage, live call transcripts anyone can overhear, and agents listening on every call. The knowledge stays in the room, where it compounds. I treat agent teams the same way.
- three-angle valuation
Valuing every Looikos brand from three sides at once: finance, software and service.
Every Looikos brand is researched and valued from three angles. The finance angle covers capital, credit and how the business could be financed or sold. The software angle covers the product and platform. The service angle covers the delivered service and its retainer economics. The thesis is that each brand stands on all three at once, and the brand decks test whether that holds.
- Unified Architecture
My claim that optimal decisions, fluid flow and quantum evolution are three views of one mathematical object, so each field's tools serve the others.
Four systems I built over about ten years, a grid trading strategy, a content pipeline, a knowledge store and a portfolio operating structure, kept coming out the same shape. The Unified Architecture is my account of why: optimal decision-making, fluid flow and quantum evolution are three projections of one mathematical object, connected by published derivations. Once that holds, the tools built for one become design primitives for the others.
- Value Optimization Framework
My offer framework: find the million-dollar problem inside a $100M business, fix it, guarantee the result, and bill the year up front.
It's built on the mechanics Alex Becker used to bootstrap his SaaS companies, one of them to $40M ARR: sell one-to-one, bill annually up front, and guarantee the result with full risk reversal. My version aims at the million-dollar problem inside a $100M business. The buyer gets two fair doors: pay a year up front with a full refund if it fails, or take a small proven result first and start paying once it works.
- Voice Fingerprint
A numeric profile of how one business writes, measured from its own copy, so drafts can be checked against its real voice.
My Voice Fingerprint measures a client's own writing across nine metric families, covering vocabulary, rhythm, punctuation and sentiment, to produce a numeric profile of how that business sounds. Drafts get checked against the profile, so a voice dispute becomes a measurable distance and stops being a taste argument. On one project my first AI-assisted round used 4% contracted verbs; the rebuild landed at 87%, inside the client's 59 to 94% range.
- bridge architecture
How a piece or an offer carries a reader from where they stand to where they want to be, at a cost they can bear.
In my attention work the creator acts as a bridge between where the reader is and where they could be. Bridge architecture, which I also call crossing-architecture, is the structure that carries them across: the qualification gate, the pricing page, the People · Product · Process framework itself. It only works on people who consented to be inside the bridge.
- Convergence Flow
My architecture built on the claim that the Bellman, Navier-Stokes and Schrödinger equations are three projections of one structure.
Convergence Flow is the structure I use to weave analytical frameworks together. It rests on the claim that optimal decisions (Bellman), fluid flow (Navier-Stokes) and quantum evolution (Schrödinger) share one variational structure, so tools from each can serve the others. The Loop Engine and Wardley Swarm both build on it.
- dead-paragraph eliminator
A content compiler pass, ported from LLVM's dead-code elimination, that deletes paragraphs nothing else in the piece depends on.
Compilers delete code whose results are never read. My dead-paragraph eliminator does the same to writing: each paragraph is a node with the claims it depends on and the claims it supplies, and a paragraph nothing reads is dead. Its first run on a draft of my PPP essay cut fourteen paragraphs, including one I was proud of, and the essay made the same argument.
- echo effect
The experience of reading something that sounds like the inside of your own head.
The echo effect happens when a piece names a reader's exact experience in their own language, like a writer describing the small resentment you felt standing in a supermarket queue. I build it on purpose with the Lexicon of Pain: the buyer's own phrases, read back to them in the work until they feel seen.
- fear portfolio
The specific set of fears a person has taken on in response to pain. Fears are an investment, and most people hold a terrible portfolio.
PST treats fears as investments: each one gets installed in response to pain and costs something to carry. A fear portfolio is the particular mix a persona holds, and the brand decks name it for each persona because it shows which station of the suffering loop they're stuck at. Invest too heavily in fears with no return and they chip away at identity.
- Five-Step Framework
My way of taking any program from start to finish: Scope, Plan, Strategy, Action Tree and Complete, each tied to one discipline.
The framework runs Scope through promise theory, Plan through Wardley mapping, Strategy through Warren Powell's unified decision framework, Action Tree through game theory, and Complete through Bayesian thinking, where every finish updates what I believe. It's the framework I credit with changing how I approach everything.
- human-credibility bar
The standard content has to clear before readers trust it as human work. My content compiler exists to get writing over it.
Machine-written text has a recognisable dialect, and readers have learned to spot it. The human-credibility bar is the level where content stops reading as that dialect and earns trust. I sell content that clears it, and I protect the content compiler that gets work over the bar.
- Loop Engine
My working memo on open loops: the unresolved questions that hold attention in hypnosis, TV, stand-up and songs, and the math underneath.
A comedian opens a loop in the first minute and pays it off in the last; a showrunner ends an episode on one. The Loop Engine treats the loop as the unit of held attention, explained by predictive processing: an open loop is a live hypothesis the audience can't yet confirm. I connect it to my Convergence Flow architecture and mark which parts are established and which are my hypothesis.
- Seven Layers Deep
My rule that every diagnosis digs seven layers below the complaint a client opens with before I recommend any deliverable.
A client's opening complaint rarely names the problem underneath: 'I need more leads' usually means 'I'm afraid my business doesn't work.' Seven Layers Deep is my rule, learned during a year at a therapy clinic, that a diagnostic keeps digging before anything gets prescribed, so I never propose a fix for the wrong layer of pain.
Borrowed and redefined
- alpha
An edge your competitors know about, have probably tried, and still won't pursue, because it doesn't fit how they're built.
In finance, alpha is return beyond what the market gives everyone. My working definition: alpha is the thing your competitors are aware of, have probably tried, may have seen results from, and still won't do, because for their structure it doesn't make sense. It has to compound privately. In my compiler writing, the content compiler is the alpha and the media it produces is the product.
- Content Compiler
My system that treats writing like code: it breaks a piece into typed parts, checks each one, and rewrites only the part that fails.
A content compiler decides what a piece says. It breaks the draft into parts, gives each part a job, and cuts whatever doesn't earn its place. Mine stores every paragraph as its own record with its own status and runs passes over them for structure, voice, citations and logic. When one paragraph fails, only that one gets regenerated, which by my design estimate cuts the context a revision needs by about 90% against re-rolling the whole draft.
- echolocation
Understanding a customer by sending questions into their whole world and rebuilding it from what comes back, the way a bat maps a cave.
Demographics light only the patch of wall nearest the lamp. Echolocation pings instead: you send questions into a customer's whole world (their economy, their own customers, the supply chain, the flow of money and blame) and reconstruct the room from the returns. It's the first step of my PST framework, and the origin of most of what I write about sensing a market.
- harness
Everything around an AI model that turns it into dependable work: its tasks, tools, rules, memory, checks and records.
An agent harness is the software that hands AI agents their tasks, tools and rules, then checks their work. Under the hood mine is mostly YAML, markdown and JSON: prompts, skills, personas, hooks, reference material, SOPs, data models, evaluation loops and observability. The model supplies raw intelligence, and the harness makes it reliable enough to run a business on.
- metagraph
A graph where the connections themselves carry facts: confidence, source, and the dates they were true. It's my agents' shared memory.
A plain graph links things to things. A metagraph also lets you point at the link itself and record your confidence in it, where it came from, when it was true and what contradicts it. That's what lets a world model revise a belief when evidence moves. My working version, which I call the Metagraph, runs on Graphiti and Neo4j and serves as the shared memory my AI agents read before acting and write to afterward.
- third door
When bigger competitors lock the front and back doors to a market, the third door is the creative route they won't take.
Picture a competitor with hundreds of people, more money and more patience than you. The front door and the back door are both locked. The third door is the route they won't take, the alpha, found with creativity and then done better than anyone else can, at scale. Every Looikos brand deck has a section naming where its third door is.
- Velvet Rope
My qualification system: marketing, intake and calls built so wrong-fit prospects disqualify themselves before they ever see a price.
The name comes from the rope outside a club, which sorts the line without saying a word. My Velvet Rope has three surfaces: what your marketing says before anyone talks to you, how your intake screens people before a call, and what you ask on the call. Each filters harder than the last, so a prospect who reaches your calendar has already passed two checkpoints. It's Stage 7 of People · Product · Process, built as a system.
- world model
A living, queryable model of a business, market or domain that agents read before acting and update as the evidence changes.
I use world model for a structured model of a client's world: their customers, competitors, products and decisions, and what's known about each, with dates and sources. Agents query it before they act and write back to it afterward. It's the line where a store stops being a database: it knows what it knows, its confidence, and when that changed.
- belief structure
In PST, the set of beliefs a person's suffering loop runs on, built from repeated emotional experiences and driving their behavior.
The belief structure is the Story in PST. Repeated emotional experiences build beliefs, beliefs drive actions, and actions produce results, habits and eventually personality. I work on the structure before its origin, because the structure is where change starts. Every Looikos persona gets one written out, along with the uncomfortable layer people skip: where they fell short, and the shame they carry about it.
- crossable
A transformation pitched so the audience can make it across: enough discomfort to move them, short of a mugging.
When I design a transformation in PST, I calibrate how hard the bridge asks people to work. Crossable means the discomfort is bounded so a real person can get across. Too soft and nothing changes; too harsh and it reads as a mugging, and they flinch. Audiences who've been burned before need the most careful calibration.
- harness engineering
Building the scaffolding that runs AI agents, from prompts and skills to hooks, data models, checks and observability, so it holds up in production.
Harness engineering is building and tuning everything around AI agents so their output holds up in production. SuperHarness is the brand where I teach it, release open-source plugins and sell buildouts. Its central claim is that every serious harness resolves into the same set of organs, and the judgment about how they compose under load is the hard part.
- medallion tiers
My five-step grading of data and assets, bronze, silver, gold, platinum, diamond, set by where each came from and what it proved.
Data engineers refine data through bronze, silver and gold layers as it gets cleaner. I extend the ladder to five steps and tie each to evidence. Bronze is raw source material. Silver is derived or cleaned. Gold is proven by tracked real-world events. Platinum composes several golds, like a playbook distilled from proven pieces. Diamond is mission-critical and doesn't break.
- operator
The person running a business day to day, usually its owner or founder, who makes the calls and lives with the results.
When I write operator, I mean the person who runs the business and makes the calls, usually a small-business owner or founder. Information counts as intelligence only when it changes what an operator does on a Tuesday morning. My work is built for operators more than for analysts or vendors, which is why so much of it starts from the decision they're about to make.
- productized
A service that used to be delivered by hand, turned into a repeatable offer with a fixed scope, process and price.
A productized service sells a defined result with a set scope and price, delivered by a repeatable system each time. Every company in my portfolio is a productized version of a service I previously delivered as a freelancer, and much of the Looikos research asks which internal discipline a brand turns into a product.
- qualification gate
The point where a prospect has to show fit before they get your time. I run it as a gift to the right buyer.
A qualification gate is the boundary where prospects show fit before the sale goes further. I build it into copy, forms and calls as a system boundary, and I run it as a gift: the wrong fit leaves gracefully with a redirect, and the right one gets a better room. It's Stage 7 of People · Product · Process, and the Velvet Rope is the playbook for building one.
- red line
In PST, the one move a person stuck in suffering refuses to make: accountability, because it means facing the shame they buried.
In the cycle of suffering, people mask shame with denial and blame. The red line is the move they won't make, accountability, because crossing it means turning around, facing the buried shame and admitting their fears cost them control. Brand decks name where each persona stands relative to that line.
- Roadmap
The engagement every client starts with, from $2K: a diagnostic audit of where you're losing money and a written plan you keep.
The Roadmap is my entry offer, priced from $2,000 to $5,000 depending on the project. You fill out a detailed form, I do the work, and you get a diagnostic audit of your business plus a specific, ranked written plan that's yours to act on. You can hire me on a retainer to build it, or take it anywhere.
- test budget
A set amount of money split into a planned number of tests and run as live market research, so the market votes on what works.
Results in a testing round can't be promised. A test budget takes a set amount of money, breaks it into pieces, runs a set number of tests, and treats the whole run as live market research: who buys, which creative and headlines work, and what the next round should cost. Every paid-acquisition engagement I take includes one. It doubles as risk reversal for the buyer and an exit for engagements that shouldn't continue.
- typed
Data with a declared shape: every field has a fixed type that code checks, so bad values fail loudly at the boundary.
When I say typed, I mean every piece of data has a declared shape that code checks: a citation is an object with required fields, and a loose string fails the check. Typed data fails loudly at the boundary and keeps corruption from spreading downstream, which is why typed passes, typed citations and type-safe data models run through everything I build.
- value rubric
The scoring method that ranks every Looikos brand and capability against the others to set what gets built first.
The value rubric weighs each brand, and each capability on the build wish-list, against the others, so priority comes from a score. Each deck's priority read is one input. The rubric also checks itself against seven named biases that inflate a score, its seven sins. Wardley Swarm is the brand that would turn its method into a product.
- Day in the Life test
Asking existing customers about an ordinary Tuesday until their answer contains something a photograph could capture.
Stage 2 of People · Product · Process needs the customer's desired future described in things you could photograph. The Day in the Life test gets there: ask three existing customers about a Tuesday and push until their answer is that concrete. Those answers become the future you sell. I re-run it twice a year, because the future a client wants shifts after a year of working together.
- drift
Slow, silent change away from what a system was built or tuned for, in data, model behavior, document structure or a writer's voice.
I use drift for any quiet departure from a baseline: data that moves away from what a model was tuned on, a provider changing a model's behavior, structure that shifts each time a draft regenerates, or copy that wanders from a client's measured voice. My systems ship with drift monitoring, so it shows up as a number before a customer notices.
- feature factory
A self-contained production line inside a Looikos platform, owning one domain with a clean boundary and running on shared systems.
In the Looikos decks a platform breaks into feature factories, each owning one domain with a clean boundary, like a web-and-commerce factory or a 2D-and-data-visualization pipeline. Each runs on the shared agent harness and metagraph, so standing up a new brand means assembling factories you already have.
- Field note
A short, current wiki entry from work in progress, like a build log, an observation or a lesson, lighter than a full guide.
My wiki has two kinds of entries. Guides are the canonical, deeper references. Field notes are short, tactical and current: build logs, forensic observations from inside the work, and reading notes, written in a more casual register. They earn the visit, and the guides hold the full argument.
- Forward Deployed AI Engineering
How WikiDesignCo is rented: the platform and the engineering judgment behind it, embedded in a business for one flat monthly fee.
Forward Deployed AI Engineering is the offer WikiDesignCo sells: the data platform and the engineering judgment behind it, embedded in an operator's business for one flat monthly number per tier. The operator gets a data platform and working AI systems without making the expensive two-engineer hire it would take in-house.
- laminar depth
The two layers of media in my Standard Model: a churning top layer built for distribution, and a calm laminar depth that carries the meaning.
The terms come from fluid dynamics, where laminar flow runs in smooth layers and turbulent flow churns. In my Standard Model the turbulent surface is the part that has to satisfy a distribution system: the format, the hook, the first three seconds. The laminar depth runs underneath, steady and predictable, carrying the idea the reader keeps. Each time, I say where the physics is real and where it's only an analogy.
- market-maker read
Reading a brand the way a market maker reads an asset: on its fundamentals, its technicals and the sentiment around it.
Every Looikos deck reads its brand the way a market maker reads an asset, at three levels. Fundamentals ask whether the business underneath is sound. Technicals look at how the category lands and expands with customers. Sentiment asks how buyers and investors regard the category right now. A favorable read on all three raises the brand's priority.
- min-maxxing
A gamer's word: put your limited points where the run spends its time, and strip whatever never fires. I apply it to tech stacks.
In a character build you get finite points, and the winning build puts them where the run spends its time. Applied to a tech stack it means asking, over and over, what the tools I already have can do that I'm not asking them to do, and pushing each one to its plateau before adding another. Min-maxxing this site's stack left three systems doing work that usually takes a team and a vendor list.
- rugged
Crypto slang: when the people behind a project walk away with the value, leaving the community holding the losses.
Getting rugged, short for rug-pulled, means the people behind a crypto project take the value at the community's expense. I was rugged on a project I helped scale from $10M to over $100M market cap, when the investor behind it wouldn't ship what had been promised. It taught me that investor character matters more than the team's technical talent.
- seven sins
Seven classic backtesting errors, each named after a deadly sin, turned on my own analysis to catch a score that's been inflated.
The seven sins are the ways an analysis fools itself: pride as look-ahead (assuming you knew then what you know now), lust as capacity delusion, gluttony as overfitting, envy as survivorship bias, greed as fat-tail risk, wrath as regime-blindness, and sloth as ignoring transaction costs. They started as backtesting errors in trading, and every Looikos brand deck states how its read avoids them.
- slop
Generic machine-written content: grammatically clean, plausible, and written for nobody in particular.
Slop is my word for AI output that's polished and empty, the average of everything the model absorbed with no particular person behind it. Clean grammar doesn't save it. Every post I called slop had clean grammar, so I traced each verdict to a pattern and wrote it down. The voice compiler exists to keep it out.
- substrate
The shared base layer something runs on or reads from, like a data platform beneath many products, or a transcript a team works from.
I use substrate for the base layer other things depend on. WikiDesignCo is the data substrate the Looikos brands read through; a clean knowledge base is the substrate an AI assistant retrieves from; on The Floor, the live call transcript is the shared substrate a sales pod overhears. Moving knowledge into a shared substrate is how it stops living in one head.
Technical
- embeddings
Lists of numbers that place text, images or video in a shared space, so similar meanings sit close together and can be searched.
An embedding turns a piece of content into a long list of numbers, a coordinate, so things with similar meaning land near each other, and search by meaning finds the nearest coordinates. I use 3072-dimension embeddings where text, images and video share one space. Embeddings are necessary and not sufficient: good retrieval also needs exact-word search, a graph and reranking.
- intermediate representation
A neutral middle format that many inputs translate into and many outputs are produced from, so each side only has to be built once.
In compilers, an intermediate representation (IR) is the middle language: every source language compiles into it and every target is produced from it, so twenty languages and fifteen targets need thirty-five pieces of work, down from three hundred separate compilers. I apply the same trick to content and data. My content compiler treats a document as a typed IR, and one typed data model feeds every database and interface.
- MCP
Model Context Protocol: the standard way AI agents connect to outside tools and data sources and call them.
MCP, the Model Context Protocol, is an open standard that lets AI agents call tools and read data from other systems through one common interface. My retrieval engine exposes my 5-million-word corpus through an MCP server so any agent can query it, and several of my products expose their core operations the same way, beside a regular API.
- observability
Designing systems so they can be questioned after the fact: every operation records what it was given, what it did and how long it took.
Observability is the discipline of designing systems that can be interrogated. A function that succeeds ten thousand times a day tells you nothing about how long it took, what it was handed, or which successes were garbage, unless something wrote it down. Every system I ship records timed spans for its operations, usually in LogFire, so failures get diagnosed from evidence. My rule: if it isn't in LogFire, it didn't happen.
- RAG
Retrieval-augmented generation: an AI system that first looks up relevant passages in your documents, then writes its answer from them.
RAG stands for retrieval-augmented generation. Before the model answers, a retrieval step pulls the passages closest to the question and hands them over to read. I run it as a four-stage pipeline with every stage instrumented and testable, and citations treated as first-class objects. It answers 'what's our refund window?' beautifully and struggles with questions whose answer runs across hundreds of documents.
- agentic
Describes AI systems that take steps toward a goal on their own, choosing tools and actions as they go.
An agentic system gives an AI model a goal, tools and some freedom to plan and act in steps, then checks the results; an agentic workflow chains those steps. I build them with visible tool calls, evals and observability, because a demo that works and a system that holds up when fifty customers hit it at once are different problems.
- AI agent
A software worker built on an AI model, with a goal, tools it can call and memory, working through a task step by step.
Agents are composable units of policy, tools and memory. My business runs on a team of them that plan, build and check work in parallel, sharing one memory. I design each with Agent Redwood before building it, and no agent checks its own work: a separate agent uses the deployed work and reads the database back before anything ships.
- attribution
Working out which ads, channels or touches deserve credit for a sale. It's a problem nobody can solve perfectly.
Attribution assigns credit for a conversion across the touches that came before it. It's a credit-assignment problem you can't fully solve, so I pick the model the decision needs. It also depends on what got recorded: a checkout that never stored which click led to an order can't tell you which campaign made the money.
- bitemporal
Storing two dates for every fact: when it was true in the world, and when the system recorded it.
A bitemporal record keeps two clocks: when a fact was true in the world and when the system learned it. That lets you ask what was true last month and what you believed last month as separate questions. My agents' memory works this way: a newer fact closes the old one with an end date and leaves it on the record, so nothing gets silently overwritten.
- corpus
A body of collected text, like transcripts, reviews, notes or articles, gathered so it can be searched and analyzed as one.
A corpus is a collected body of language treated as one dataset. Mine is about 5 million words of my own writing and notes, indexed so AndyDataBot and my agents can answer from it. For a client it's often their calls, tickets, reviews and proposals, and much of my work is finding out what that corpus can and can't answer.
- data mesh
An architecture where each domain team owns and publishes its data as a product, under shared contracts and automated governance.
Zhamak Dehghani's data mesh rests on four principles: domain ownership, data as a product, a self-serve platform, and governance written as code. Human organizations mostly couldn't sustain the daily discipline it demands. My argument in The Mesh Finally Ships is that agents can, because for an agent those disciplines are the minimum conditions for working at all.
- ECS
Entity-Component-System: a game-engine pattern where things are plain identities, data lives in components, and systems are functions over that data.
ECS comes from game engines. An entity is just an identity, components are typed pieces of data attached to it, and systems are pure functions that transform entities. Data-oriented design is the unifying idea, and ECS is its game-engine expression. I use it as the shape for data models across the Looikos brands, alongside Pydantic-as-IR.
- evals
Regression tests for AI systems: a fixed set of questions with known-good answers that every change gets scored against.
Evals are regression tests for model systems. An eval set might be thirty held-out questions with known-correct sources, and every change to a prompt, model or retrieval step gets scored against it. An AI feature without evals is a science experiment with users in the lab. When the pass rate drops, the failing rows point to the exact trace where something went wrong.
- Graphiti
An open-source temporal knowledge graph library on Neo4j, which I extended and host as my agents' shared memory.
Graphiti builds a knowledge graph where every fact carries validity windows: when it became true and when it was superseded. I extended it and host it myself on Neo4j, and it's the working instance of my metagraph. I also built a save path that writes each entry to disk, writes it to the graph and reads it back, because the stock tool reported success before the save had landed.
- knowledge graph
A database that stores things and the named relationships between them, so you can ask how facts connect.
A knowledge graph stores entities, like people, products, companies and decisions, and the typed relationships between them, the way a map shows cities connected by highways. It answers questions about connections that a pile of documents can't. My agents' memory goes two steps further, to a hypergraph and then a metagraph, so a relationship can bind many parties and carry its own sources and dates.
- LangGraph
A Python library for building AI agent workflows as graphs of steps with shared state, conditions and loops.
LangGraph models a workflow as a state machine: nodes that do work, edges that carry conditions, and shared state. It's my orchestration layer on the Python side, and it also gave me the vocabulary I now use for work with no agents in it at all, like hiring and client onboarding.
- LLM
Large language model: the kind of AI model behind chat assistants, trained on huge amounts of text to predict the next word.
An LLM is trained by predicting the next token across a vast mass of human writing, so it writes toward the average of everything it absorbed. In my systems it's one component among several, wrapped in typed contracts, retrieval, evals and observability. In my trading work an LLM is forbidden from emitting raw buy and sell calls, because a system mirrors whatever its reward function says.
- LLVM
A widely used compiler toolkit whose shared middle format lets many languages reach many machines. It's my model for content and data systems.
LLVM is the compiler infrastructure behind front ends like Clang, rustc and Swift. Each language compiles into one shared intermediate representation, and each machine target compiles out of it, which collapses the work from M×N to M+N. I borrow from it directly: my content compiler is inspired by LLVM's IR and ports its passes, like dead-code elimination, to paragraphs.
- LogFire
An observability tool that records every operation in a system as timed, nested traces I can inspect after the fact.
LogFire is the observability layer across my stack. Each operation logs a span with its inputs, outputs and timing, so when an eval's pass rate drops I can open the failing trace and see exactly which tool call went wrong. My rule is blunt: if it isn't in LogFire, it didn't happen.
- optimization pass
One function that reads a whole intermediate representation and returns an improved version. Compilers chain many of them in a row.
A pass takes the IR and returns a modified IR. Good passes are idempotent (running one twice equals running it once), pure (they touch nothing outside the IR) and composable (their order is configuration). My content compiler runs structure, voice, citation and render passes over every document, and each one logs what it changed.
- provenance
The record of where a fact came from, what produced it and what it depends on.
Provenance is a fact's source trail: which document, conversation or processing run produced it and what it rests on. In my systems every fact carries one, alongside a confidence score and the dates it was true, because a fact needs a source trail and a clock before another decision can safely reuse it. Like time, it can't be retrofitted.
- Pydantic
A Python library for defining data as typed models that validate themselves. It's the foundation of most of what I build.
Pydantic lets you declare the shape of your data as Python classes with typed fields, and it rejects data that doesn't fit. I treat the Pydantic model as the source of truth for a system, pair it with LogFire for tracing and Hypothesis for testing, and build agents with PydanticAI so they return typed results. 'We use Pydantic and LogFire' is a feature.
- reward function
The score an optimizing system is built to maximize. Get it slightly wrong and the system chases the wrong thing perfectly.
A reward function tells an algorithm what better means. My expensive lesson: an ad-bidding system I rewarded for conversions in a 24-hour window learned to spend more to buy more conversions, even ones costing twice what they earned. The math was correct and the instruction was wrong. Designing the reward function as carefully as the algorithm is one of the three commitments of intelligence engineering.
- tokens
The small word-pieces AI models read and write. Usage is billed per token, so regenerating a whole draft costs as much as writing it.
Language models read and write in tokens, chunks of a few characters each, and providers bill by the token. That's why my content compiler re-renders one block at a time: changing one paragraph costs roughly two to four percent of regenerating the full document, which is where the figure of about 90% fewer tokens per revision comes from.
- voice-of-customer research
Research that collects how customers describe their problems in their own words, from reviews, calls, forums and support tickets.
Voice-of-customer research gathers what buyers say, in their own words, before anyone writes copy or builds a funnel. It's the raw material for my Lexicon of Pain and for Stage 1 of People · Product · Process. The Looikos brand decks quote persona language mined this way so each persona speaks the way real buyers do.
- Wardley map
A strategy map placing each part of a business by its stage of evolution, novel to commodity, to decide what to build or buy.
Wardley mapping lays out the components a user need depends on and places each by its evolution, from genesis to commodity. I use it to decide what to own and what to rent or harvest: build what's novel and differentiating, buy what's commodity. Every Looikos brand deck carries a Wardley read, and Wardley Swarm would turn the method into a product.
- Archon
An open-source retrieval platform. My local retrieval system and WikiDesignCo's first search core were built on it.
Archon is an open-source RAG platform covering web crawling, document processing, chunking, embedding, indexing and retrieval over MCP. I run a local retrieval system on it with custom chunkers, and WikiDesignCo's first live build forked it, because retrieval at that layer is a commodity worth renting.
- ARR
Annual recurring revenue: the yearly value of the subscription or retainer income a business can count on.
ARR is the annualized value of recurring contracts. Companies are often valued as a multiple of it, which is why recurring retainer revenue carries so much weight in the Looikos brand decks: predictable income lifts the valuation multiple and makes a business easier to finance.
- Atomspace
OpenCog's typed knowledge store, where links can point at other links. It's my long-term target for a true metagraph.
Atomspace, from Ben Goertzel's OpenCog project, stores knowledge as typed atoms, where any node or link can itself be the subject of other links, which is what 'edges pointing at edges' means technically. It's the top of my memory build tiers: Graphiti on Neo4j ships today, and Atomspace is a true metagraph to grow toward.
- backtesting
Testing a trading strategy against historical market data to see how it would have performed before any real money is at risk.
Backtesting replays a strategy against past data. It's where trading systems most often fool themselves, through classic errors like look-ahead, assuming you knew back then what you know now. I turned those errors, the seven sins, on my own analysis outside trading as well.
- Bellman equation
The equation behind optimal step-by-step decisions: the best move now accounts for the value of everything it leads to.
Richard Bellman's equation formalises decisions made in sequence: the best move at each step weighs its immediate reward against the value of the states it leads to. It's the decision leg of my Unified Architecture and Convergence Flow work, where I treat it, Navier-Stokes and Schrödinger as three projections of one underlying structure.
- CAC
Customer acquisition cost: what you spend on marketing and sales to win one new customer.
CAC divides what you spent to acquire customers by how many you got. I diagnose each acquisition channel through its CAC payback window, meaning how long a new customer takes to earn back what they cost, and through cohort retention, before any spend scales.
- CLI
Command-line interface: a way to run a program by typing commands in a terminal, used heavily by engineers and AI agents.
A CLI lets a program be driven by typed commands. My products expose one beside the web app and the API, all thin adapters over the same core. Agents use them constantly: my agents' memory has a save path any agent can run from a command line.
- cluster-semantic chunking
Cutting a large body of text into retrieval-sized pieces wherever the topic changes, so each piece holds one topic.
Before documents can be searched by meaning, they get cut into pieces called chunks. Cluster-semantic chunking cuts where the topic shifts, so each chunk an agent gets back holds one coherent topic. My retrieval engine uses custom chunkers built this way across a 5-million-word corpus.
- cohort analysis
Comparing groups of customers who started in the same period to see how their buying and retention change over time.
Cohort analysis groups customers by when they started and follows each group over time, which shows whether newer customers behave better or worse than older ones. It sat behind the work on a DTC metal-art brand that went from $10K to $150K a month in 90 days.
- comps
Comparables: similar companies or deals whose prices serve as a reference for valuing a business.
Comps are the reference class for a valuation: named acquisitions and companies like the one being valued, with their prices and multiples. Every Looikos brand deck lists its M&A and valuation comps, preferring recent, named deals.
- Convex
A hosted reactive database and backend that holds andydataguy.com's data, runs its scheduled jobs and serves its search.
Convex is the data layer under andydataguy.com and several of my products: database, file storage, scheduled jobs and real-time queries in one service. While min-maxxing the site's stack I pushed it to do five jobs that usually need separate services, so the whole system fits in one person's head: Next.js renders, Convex holds the data, Python runs the pipelines.
- CPA
Cost per acquisition: what you pay in ad spend for each sale or signup.
CPA is ad spend divided by the number of sales or signups it produced. In one ecommerce account, new video creative cut it from about $80 to about $45. I read it beside what each conversion earns, because conversions that cost twice what they earn can still look cheap on a dashboard.
- CPL
Cost per lead: ad spend divided by the number of leads it produced.
CPL measures what each new lead costs. In one agency funnel I replaced a short form with an application of fifteen-plus questions. Time-wasters filtered themselves out, the ad pixel retrained on serious applicants, and cost per qualified lead fell from about $50 to under $10.
- CRO
Conversion rate optimization: raising the share of visitors who take the action you want, through tested changes.
CRO is the work of raising the share of visitors who buy, book or sign up. I run it as a discipline of falsifiable hypotheses tested against statistical floors, grounded in what real buyers say, and paired with the ad account so the traffic and the page get fixed as one system.
- CTR
Click-through rate: the share of people who see an ad or link and click it.
CTR is clicks divided by impressions. A high CTR shows an ad gets attention, which is different from sales: in one garden metal art account, strong clicks never turned into a profitable path, and I documented that failure as a case study.
- DAG
Directed acyclic graph: a set of steps with one-way dependencies and no loops, the usual shape of a data pipeline.
A DAG lays out steps where each depends only on earlier ones and nothing loops back. Most pipeline tools are built around them. Real work gets sent back for rework, which is one reason I model operations as state machines that allow cycles.
- DTC
Direct-to-consumer: brands that sell their own products straight to customers online, with no retailer in between.
DTC brands sell straight to customers, usually through their own store and paid social. I built three ecommerce brands past seven figures this way, including a DTC metal-art business that went from $10K a month to $150K a month in 90 days.
- EBITDA
Earnings before interest, taxes, depreciation and amortization: a standard measure of operating profit used to value businesses.
EBITDA approximates the profit a business's operations produce. Agencies and service businesses often sell for a multiple of it, and the Looikos decks use those multiples, from named roll-up precedents, to estimate what a brand could be worth.
- FastAPI
A Python framework for building web APIs with typed inputs and outputs.
FastAPI is how I expose Python services, like the content compiler, to the rest of a system over HTTP. Its inputs and outputs are Pydantic models, so the same typed definitions that describe the data also describe the API.
- GTM
Go-to-market: how a product reaches buyers, covering who it's for, the price, the channel and how the sale closes.
GTM is the plan for selling: who the buyer is, how they hear about you, what it costs and how the deal closes. My Value Optimization Framework piece follows one founder's GTM through four eras, each one selling a bigger result to a buyer with more money.
- hexagonal architecture
Ports and adapters: one core of business logic behind thin adapters for each interface, so the web app, API, CLI and agents share one core.
Alistair Cockburn's hexagonal pattern separates business logic from transport. The core does the work and knows nothing about HTTP, a command line or an agent; each interface is a thin adapter over it. My products follow it, so one core serves the web app, the API, the CLI and the MCP surface with zero duplication.
- hypergraph
A graph where one connection can bind many participants at once, the way one meeting joins five people in a single event.
In an ordinary graph every edge joins two things, so a five-person meeting becomes ten separate pairs that forget they belong together. A hypergraph lets one edge bind all five at once, which matches the shape a real event has. It's the middle step on my path from a graph to a metagraph.
- ICP
Ideal customer profile: a detailed description of the buyer a business serves best.
An ICP describes the customer you're built to serve. Mine runs to 180 points for every engagement, built so I never again propose a fix to the wrong layer of a buyer's pain.
- incrementality
How much of a result an ad or channel caused, beyond what would have happened anyway.
Incrementality testing is the only method that answers the counterfactual question directly: which of these sales wouldn't have happened without the ad? Platform reports often show stronger results than incrementality tests do, because the platform takes credit for conversions that would have happened organically. I run these tests quarterly, since they cost real budget and need time to reach a reliable answer.
- LTV
Lifetime value: the total revenue or profit a customer brings in over the whole relationship.
LTV estimates what a customer is worth across the whole time they keep buying. Set against CAC, it tells you how much you can afford to spend to win one, and which customers and channels deserve more budget.
- MVP
Minimum viable product: the smallest version of something that works for real users and proves the idea.
An MVP is the smallest build that does the job for real users. My principle is to ship one in days or weeks, a rule I hold because I've paid the bill for months-long builds that never shipped. The content compiler, for instance, is an MVP running in production on my own writing.
- Neo4j
A graph database that stores nodes and the relationships between them. It sits under Graphiti in my agents' memory.
Neo4j is a graph database built around nodes and the relationships between them. It hosts my Graphiti memory today. It's a fine product and still a poor warehouse, because every data shape answers some questions cheaply and others badly.
- orchestration
Coordinating many steps or agents so each runs in the right order with the right inputs, handles failures and hands off cleanly.
Orchestration is the layer that sequences work across steps or agents: what runs next, with which input, and what happens on failure. I use LangGraph for it on the Python side. In one build, state management, conditional edges and the Send API covered what a separate orchestrator server used to do, so the server went away.
- policy-first
Starting with the simplest decision rule that could work, and adding complexity only once the value proves it's needed.
Policy-first comes from Warren Powell's unified framework for sequential decisions, which sorts every way of acting into four policy classes. Most of the time a simple policy is all you need, so I escalate only when it fails. Agent Redwood carries the same posture into agent design.
- PPC
Pay-per-click: paid ads, on search or social platforms, where the advertiser pays each time someone clicks.
PPC is paid advertising billed per click. I run PPC and CRO as one engineered system, treating the ad account and the landing page as a single machine, because the ad's promise and the page's proof succeed or fail together.
- PRD
Product requirements document: the written spec of what a product or feature must do, for whom, and how success gets judged.
A PRD defines what gets built before anyone builds it. PRD Master, a Looikos infrastructure brand, generates PRDs and the other operating documents, like SOPs, READMEs, configs, templates and agent skill definitions, that downstream systems run against.
- primitive
A basic building block that other things are composed from, like data modelling, document generation or retrieval in my systems.
A primitive is a capability simple and general enough that many products get built from it. Among the Looikos brands, Story Factory is the document-generation primitive and Scatter Model the data-modelling primitive, which is why they sit with the infrastructure brands. In one stack rebuild, three library primitives, state, conditional edges and the Send API, replaced a whole orchestration tool.
- promise theory
Mark Burgess's framework for modelling a system as components that each make, and depend on, explicit promises.
Promise theory models a system as parts that each promise something and rely on the promises of others. I use it to scope work and map dependencies: what each component promises, what it needs, and which foundational pieces everything else waits on. It's the Scope step of my Five-Step Framework.
- property-based testing
Testing by generating many random valid inputs and checking that rules about the outputs always hold.
Property-based tests generate random valid inputs and check invariants on the outputs, which covers far more cases than a handful of hand-written examples. I use Hypothesis for Python and fast-check for TypeScript. Paired with observability and typed data models, it gives a small team reliability that usually takes a much bigger one.
- Quant
Short for quantitative: trading and research driven by math, statistics and code. Also the Looikos family of finance brands.
Quant work uses math, statistics and code to research and trade markets. Quant & Finance is one of the four Looikos categories, with brands like Quant Scientist, a trading platform and mission control. My habits around precision come from algorithmic trading, where a single data bug could cost someone their house.
- Remotion
A framework for making video with code, so animations can be data-driven, versioned and reused.
Remotion defines video as React code, which makes animation parametric, reusable, version-controlled and bound to data. It's the base of the 2D and data-visualization pipeline in the Looikos content brands, alongside Three.js for 3D work.
- repo
Short for repository: a project's code and its full history, stored in version control like Git.
A repo holds a project's code and every change made to it. The Looikos research scouts open-source repos for capabilities worth harvesting so they don't get built from scratch, and each brand deck lists the repos its build would draw on.
- reranker
A second pass that re-scores retrieved passages for real relevance before the AI reads them.
Retrieval often runs several searches at once, by meaning, by exact words and by graph links, and the combined results are too noisy for a model to read. A reranker, usually a cross-encoder, re-scores each candidate against the question and keeps the best. It's the piece most teams skip, and in my retrieval guides it's the load-bearing one.
- ROAS
Return on ad spend: revenue credited to ads divided by what the ads cost.
ROAS is revenue credited to advertising divided by ad spend. The number is only as good as the attribution behind it: a dashboard can report record performance while the bank account keeps shrinking, because the platform credits itself for sales it didn't cause.
- schema
The declared structure of stored data: which fields exist, their types, and how records link. It sets the questions you can ever ask.
A schema is the blueprint for stored data: its tables or documents, fields, types and keys. In my Shape of Data series the schema is the first executable artifact, because a field that was never recorded can't be analysed later, however good the tools on top.
- SDK
Software development kit: a package of code libraries that lets developers use a platform from inside their own programs.
An SDK wraps a platform's API in ready-made code for a given language. In the Looikos decks it's usually the thinnest of a product's surfaces, sitting beside the web app, the API, the CLI and the MCP interface over one shared core.
- Solana
A public blockchain known for fast, cheap transactions. Several Looikos brands and my tokenomics work are built around it.
Solana is a public blockchain known for fast, low-cost transactions. I worked on tokenomics and incentive design for over two dozen Solana projects, and Looikos brands like Solana Brain build agent-ready knowledge layers for the developers working on it.
- SOPs
Standard operating procedures: written step-by-step instructions for doing a recurring job the same way every time.
SOPs record the current best way to do a recurring job. My agents follow SOPs written for machine readers: how to hand off, how to report, what evidence a claim requires. The nine-rung hierarchy, from Mission to Event, serves as the master SOP.
- STORM
A Stanford research method for AI writing that grounds every claim in retrieved, cited sources.
STORM is a Stanford method for generating long, citation-backed writing that's grounded in sources and avoids confident confabulation. Story Factory and Wardley Swarm share its lineage: their agents research and cite before they write, so the output can be traced back to evidence.
- stylometry
Measuring a writer's style with numbers: sentence lengths, punctuation, vocabulary variety and how often small function words appear.
Stylometry is the statistical study of writing style: sentence-length average and spread, vocabulary variety, punctuation ratios, function-word frequencies. My content compiler uses about thirty such features to measure how far a draft sits from the reference range for its register. They're stylometry's oldest tools, and they still earn their rent.
- TAM
Total addressable market: the full revenue available if a product won every possible customer in its market.
TAM sizes the whole market a product could serve. The Looikos decks triangulate it from adjacent markets when no clean figure exists, and pair it with the specific niche a brand can win.
- tokenomics
The economic design of a crypto token: supply, distribution, incentives, and how value moves between holders and the project.
Tokenomics covers how a token is issued, distributed and rewarded, and what makes holding or using it worthwhile. A token launch is a protocol between several stakeholder groups, and the incentives have to work for all of them. I designed tokenomics and incentives for over two dozen Solana projects on a platform with more than $500M in TVL.
- TVL
Total value locked: the total amount of crypto deposited in a decentralized finance platform.
TVL measures how much capital users have deposited into a crypto protocol. I worked on tokenomics and incentive design for over two dozen Solana projects on a platform holding more than $500M in TVL.
The flagship Looikos agency: a technical marketing agency that models a client's market in software, then runs the story across every channel.
Social Storyboard is the first Looikos asset taken to market, launched on a cold-email campaign. It approaches marketing the way an engineer approaches a build: model the client's whole market in software, then run the story across every channel. Its case studies, packaged services and delivery systems become the template the later agency brands launch from.