Glossary
The words I use, and what I mean by them.
166 terms
0-9
- 180-point ICP profile
- see ICP
A
- actualization mode
The mode where audience and creator both pay a cost: the reader strives, the creator acts as a bridge, and something changes.
Coined
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.
- agent harness
- see harness
- 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.
Proprietary
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.
- Agent Redwood assessment
- see Agent Redwood
- Agent Redwood framework
- see Agent Redwood
- agentic
Describes AI systems that take steps toward a goal on their own, choosing tools and actions as they go.
Technical
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.
- agentic RAG
- see RAG
- agentically
- see agentic
- 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.
Technical
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.
- AI slop
- see slop
- alpha
An edge your competitors know about, have probably tried, and still won't pursue, because it doesn't fit how they're built.
Borrowed and redefined
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.
- alpha third door
- see third door
- AndyDataBot
The AI assistant on andydataguy.com. It answers from my 5-million-word personal corpus and shows where each answer came from.
Proprietary
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.
- annual recurring revenue
- see ARR
- anti-slop
- see slop
- Archon
An open-source retrieval platform. My local retrieval system and WikiDesignCo's first search core were built on it.
Technical
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.
Technical
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.
Technical
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.
- Attention Engineering
My name for the craft of earning and keeping an audience's attention, aimed at deep relationships with readers over cheap engagement.
Coined
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.
- attribution
Working out which ads, channels or touches deserve credit for a sale. It's a problem nobody can solve perfectly.
Technical
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.
- attribution model
- see attribution
- attribution modeling
- see attribution
B
- backtest
- see backtesting
- backtested
- see backtesting
- backtesting
Testing a trading strategy against historical market data to see how it would have performed before any real money is at risk.
Technical
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.
- Beggar
My name for the operator who takes every client, because an empty calendar feels more dangerous than a bad fit.
Coined
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.
- Beggar identity
- see Beggar
- belief structure
In PST, the set of beliefs a person's suffering loop runs on, built from repeated emotional experiences and driving their behavior.
Borrowed and redefined
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.
- Bellman
- see Bellman equation
- Bellman equation
The equation behind optimal step-by-step decisions: the best move now accounts for the value of everything it leads to.
Technical
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.
- bi-temporal validity
- see bitemporal
- bitemporal
Storing two dates for every fact: when it was true in the world, and when the system recorded it.
Technical
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.
- 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.
Coined
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.
- 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.
Coined
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.
- by the token
- see tokens
C
- CAC
Customer acquisition cost: what you spend on marketing and sales to win one new customer.
Technical
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.
- CAC payback
- see CAC
- Chooser
The Beggar's opposite: an operator whose qualification system lets them pick their clients.
Coined
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.
- Chooser identity
- see Chooser
- CLI
Command-line interface: a way to run a program by typing commands in a terminal, used heavily by engineers and AI agents.
Technical
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.
- click-through rate
- see CTR
- cluster-semantic chunkers
- see cluster-semantic chunking
- cluster-semantic chunking
Cutting a large body of text into retrieval-sized pieces wherever the topic changes, so each piece holds one topic.
Technical
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.
Technical
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.
- cohort retention
- see cohort analysis
- cohorts
- see cohort analysis
- command line
- see CLI
- command-line interface
- see CLI
- comparables
- see comps
- compiler pass
- see optimization pass
- comps
Comparables: similar companies or deals whose prices serve as a reference for valuing a business.
Technical
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.
- Constellation Media
The Looikos content engine: it owns every content pipeline and produces the social and editorial content for every brand and customer.
Proprietary
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.
- 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.
Borrowed and redefined
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.
- ContentFactory
My live content platform, paid for by its first client, an equipment dealership: one knowledge corpus feeding every channel its buyers read.
Proprietary
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.
- Convergence Flow
My architecture built on the claim that the Bellman, Navier-Stokes and Schrödinger equations are three projections of one structure.
Coined
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.
- Convergence Flow architecture
- see Convergence Flow
- convergence flow framework
- see Convergence Flow
- conversion rate optimization
- see CRO
- Convex
A hosted reactive database and backend that holds andydataguy.com's data, runs its scheduled jobs and serves its search.
Technical
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.
- corpus
A body of collected text, like transcripts, reviews, notes or articles, gathered so it can be searched and analyzed as one.
Technical
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.
- cost per acquisition
- see CPA
- cost per lead
- see CPL
- cost per qualified lead
- see CPL
- CPA
Cost per acquisition: what you pay in ad spend for each sale or signup.
Technical
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.
Technical
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.
Technical
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.
- cross-encoder reranker
- see reranker
- crossable
A transformation pitched so the audience can make it across: enough discomfort to move them, short of a mugging.
Borrowed and redefined
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.
- crossable bridge
- see crossable
- crossing-architecture
- see bridge architecture
- CTR
Click-through rate: the share of people who see an ad or link and click it.
Technical
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.
- customer acquisition cost
- see CAC
- cycle of growth
The upward loop that replaces fear when pain hits: truth, responsibility, healing and forgiveness, with courage as the hinge.
Coined
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.
- cycle of suffering
The loop most people walk: pain, a new fear, avoidance, a bad outcome, shame, denial, a blind spot, then more pain.
Coined
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.
D
- DAG
Directed acyclic graph: a set of steps with one-way dependencies and no loops, the usual shape of a data pipeline.
Technical
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.
- data mesh
An architecture where each domain team owns and publishes its data as a product, under shared contracts and automated governance.
Technical
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.
- day in the life
- see Day in the Life test
- Day in the Life test
Asking existing customers about an ordinary Tuesday until their answer contains something a photograph could capture.
Borrowed and redefined
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.
- dead-paragraph eliminator
A content compiler pass, ported from LLVM's dead-code elimination, that deletes paragraphs nothing else in the piece depends on.
Coined
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.
- direct-to-consumer
- see DTC
- directed acyclic graph
- see DAG
- Disconnection
My name for a feature wired through some layers and missing from others, or one fact kept in two places that drift apart.
Coined
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.
- Disconnection discipline
- see Disconnection
- Disconnection doctrine
- see Disconnection
- 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.
Borrowed and redefined
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.
- DTC
Direct-to-consumer: brands that sell their own products straight to customers online, with no retailer in between.
Technical
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.
E
- EBITDA
Earnings before interest, taxes, depreciation and amortization: a standard measure of operating profit used to value businesses.
Technical
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.
- echo effect
The experience of reading something that sounds like the inside of your own head.
Coined
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.
- echolocate
- see echolocation
- Echolocate the world
- see echolocation
- echolocating
- see echolocation
- 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.
Borrowed and redefined
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.
- ECS
Entity-Component-System: a game-engine pattern where things are plain identities, data lives in components, and systems are functions over that data.
Technical
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.
- ECS data architecture
- see ECS
- embeddings
Lists of numbers that place text, images or video in a shared space, so similar meanings sit close together and can be searched.
Technical
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.
- entity-component-system
- see ECS
- eval set
- see evals
- eval suites
- see evals
- evals
Regression tests for AI systems: a fixed set of questions with known-good answers that every change gets scored against.
Technical
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.
- event-driven data mesh
- see data mesh
F
- FastAPI
A Python framework for building web APIs with typed inputs and outputs.
Technical
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.
- 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.
Coined
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.
- feature factory
A self-contained production line inside a Looikos platform, owning one domain with a clean boundary and running on shared systems.
Borrowed and redefined
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.
Borrowed and redefined
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.
- finance angle
- see three-angle valuation
- Five-Layer Drill
Questioning down through the layers beneath a client's stated problem until reaching the one they'd never have volunteered.
Coined
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.
- 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.
Coined
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.
- 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.
Borrowed and redefined
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.
- four policy classes
- see policy-first
- 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.
Proprietary
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.
- fundamentals, technicals and sentiment
- see market-maker read
- fundamentals, technicals, sentiment
- see market-maker read
G
- giga-agency
An agency producing hyper-targeted media for hyper-specific niches at machine cost with human credibility, limited mainly by compute.
Coined
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.
- go-to-market
- see GTM
- Graphiti
An open-source temporal knowledge graph library on Neo4j, which I extended and host as my agents' shared memory.
Technical
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.
- growth cycle
- see cycle of growth
- GTM
Go-to-market: how a product reaches buyers, covering who it's for, the price, the channel and how the sale closes.
Technical
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.
H
- Hamilton-Jacobi-Bellman
- see Bellman equation
- harness
Everything around an AI model that turns it into dependable work: its tasks, tools, rules, memory, checks and records.
Borrowed and redefined
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.
- 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.
Borrowed and redefined
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.
- 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.
Proprietary
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.
- Heroic Failure
A founder working 80-hour weeks and approving everything personally. It looks like commitment, and it signals a broken operating system.
Coined
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.
- Heroic Failure indicator
- see Heroic Failure
- hexagonal
- see hexagonal architecture
- 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.
Technical
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.
- hexagonal core
- see hexagonal architecture
- hexagonal pattern
- see hexagonal architecture
- HJB equation
- see Bellman equation
- 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.
Coined
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.
- hypergraph
A graph where one connection can bind many participants at once, the way one meeting joins five people in a single event.
Technical
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.
- hyperrelevance
Knowing one group of people so well, and so currently, that what you make fits them because it was made for them.
Coined
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.
- hyperrelevance cartographer
- see Hyperrelevance Cartography
- 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.
Coined
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.
- hyperrelevant
- see hyperrelevance
I
- ICP
Ideal customer profile: a detailed description of the buyer a business serves best.
Technical
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.
- ideal customer profile
- see ICP
- incrementality
How much of a result an ad or channel caused, beyond what would have happened anyway.
Technical
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.
- incrementality testing
- see incrementality
- 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.
Coined
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.
- Intelligence Engineering
Turning raw information into systems that change real decisions. Information only counts as intelligence once it changes what an operator does.
Coined
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.
- 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.
Technical
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.
K
- knowledge graph
A database that stores things and the named relationships between them, so you can ask how facts connect.
Technical
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.
- knowledge metagraph
- see metagraph
L
- laminar
- see laminar depth
- 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.
Borrowed and redefined
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.
- LangGraph
A Python library for building AI agent workflows as graphs of steps with shared state, conditions and loops.
Technical
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.
- large language model
- see LLM
- last-click attribution
- see attribution
- Lexicon of Pain
A library of the exact words buyers use to describe their problem, collected verbatim from reviews, forums, calls and support tickets.
Coined
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.
- lifetime value
- see LTV
- LLM
Large language model: the kind of AI model behind chat assistants, trained on huge amounts of text to predict the next word.
Technical
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.
Technical
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.
- LLVM IR
- see LLVM
- LogFire
An observability tool that records every operation in a system as timed, nested traces I can inspect after the fact.
Technical
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.
- LogFire span
- see LogFire
- 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.
Proprietary
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.
- Looikos brand
- see Looikos
- Looikos cluster
- see Looikos
- Looikos ecosystem
- see Looikos
- 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.
Coined
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.
- LTV
Lifetime value: the total revenue or profit a customer brings in over the whole relationship.
Technical
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.
M
- magic button
- see Magic Button Fallacy
- market-maker read
Reading a brand the way a market maker reads an asset: on its fundamentals, its technicals and the sentiment around it.
Borrowed and redefined
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.
- MCP
Model Context Protocol: the standard way AI agents connect to outside tools and data sources and call them.
Technical
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.
- MCP server
- see MCP
- medallion
- see medallion tiers
- medallion asset tiers
- see medallion tiers
- medallion data tiers
- see medallion tiers
- medallion scale
- see medallion tiers
- 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.
Borrowed and redefined
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.
- metagraph
A graph where the connections themselves carry facts: confidence, source, and the dates they were true. It's my agents' shared memory.
Borrowed and redefined
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.
- min-max
- see min-maxxing
- min-maxxed
- see min-maxxing
- 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.
Borrowed and redefined
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.
- minimum viable product
- see MVP
- 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.
Coined
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.
- Model Context Protocol
- see MCP
- MVP
Minimum viable product: the smallest version of something that works for real users and proves the idea.
Technical
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.
N
- Navier-Stokes equations
- see Navier-Stokes
- Neo4j
A graph database that stores nodes and the relationships between them. It sits under Graphiti in my agents' memory.
Technical
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.
- nine-rung hierarchy
- see nine rungs
- nine rungs
My operating hierarchy: Mission, Objective, Initiative, Project, Task, Action, Decision, Data and Event, with Purpose above them as the rails.
Coined
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.
O
- 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.
Technical
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.
- observability layer
- see observability
- open loops
- see Loop Engine
- operational hierarchy
- see nine rungs
- operator
The person running a business day to day, usually its owner or founder, who makes the calls and lives with the results.
Borrowed and redefined
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.
- optimization pass
One function that reads a whole intermediate representation and returns an improved version. Compilers chain many of them in a row.
Technical
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.
- orchestrated
- see orchestration
- orchestration
Coordinating many steps or agents so each runs in the right order with the right inputs, handles failures and hands off cleanly.
Technical
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.
- orchestrator
- see orchestration
P
- pay-per-click
- see PPC
- 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.
Coined
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.
- per token
- see tokens
- personal corpus
- see corpus
- policy-first
Starting with the simplest decision rule that could work, and adding complexity only once the value proves it's needed.
Technical
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.
- policy-first discipline
- see policy-first
- ports and adapters
- see hexagonal architecture
- PPC
Pay-per-click: paid ads, on search or social platforms, where the advertiser pays each time someone clicks.
Technical
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.
- PPP
- see People · Product · Process
- PPP framework
- see People · Product · Process
- PRD
Product requirements document: the written spec of what a product or feature must do, for whom, and how success gets judged.
Technical
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.
- premium-at-accessible boutique delivery
- see premium-at-accessible
- premium quality at accessible pricing
- see premium-at-accessible
- primitive
A basic building block that other things are composed from, like data modelling, document generation or retrieval in my systems.
Technical
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.
- Problem Story Transformation
- see PST
- product requirements document
- see PRD
- productization
- see productized
- productize
- see productized
- productized
A service that used to be delivered by hand, turned into a repeatable offer with a fixed scope, process and price.
Borrowed and redefined
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.
- productized service
- see productized
- productized version
- see productized
- productizing
- see productized
- projection mode
The mode where an audience meets its own echo: the creator flatters, the audience feels something and changes nothing.
Coined
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.
- promise-dependency graph
- see promise theory
- promise theory
Mark Burgess's framework for modelling a system as components that each make, and depend on, explicit promises.
Technical
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.
Technical
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.
- property-based tests
- see property-based testing
- provenance
The record of where a fact came from, what produced it and what it depends on.
Technical
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.
- PST
Problem, Story, Transformation: my model for understanding a customer well enough to convert and serve them, far below demographics.
Coined
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.
- PST framework
- see PST
- Pydantic
A Python library for defining data as typed models that validate themselves. It's the foundation of most of what I build.
Technical
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.
- 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.
Coined
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.
- Pydantic-IR
- see Pydantic-as-IR
- Pydantic-IR genome
- see Pydantic-as-IR
- Pydantic models
- see Pydantic
- Pydantic V2
- see Pydantic
- PydanticAI
- see Pydantic
Q
- 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.
Borrowed and redefined
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.
- Quant
Short for quantitative: trading and research driven by math, statistics and code. Also the Looikos family of finance brands.
Technical
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.
R
- RAG
Retrieval-augmented generation: an AI system that first looks up relevant passages in your documents, then writes its answer from them.
Technical
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.
- RAG pipeline
- see RAG
- red line
In PST, the one move a person stuck in suffering refuses to make: accountability, because it means facing the shame they buried.
Borrowed and redefined
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.
- red line of accountability
- see red line
- Remotion
A framework for making video with code, so animations can be data-driven, versioned and reused.
Technical
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.
Technical
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.
- repository
- see repo
- rerank
- see reranker
- reranked
- see reranker
- reranker
A second pass that re-scores retrieved passages for real relevance before the AI reads them.
Technical
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.
- reranking
- see reranker
- retrieval-augmented generation
- see RAG
- return on ad spend
- see ROAS
- reward function
The score an optimizing system is built to maximize. Get it slightly wrong and the system chases the wrong thing perfectly.
Technical
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.
- Roadmap
The engagement every client starts with, from $2K: a diagnostic audit of where you're losing money and a written plan you keep.
Borrowed and redefined
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.
- ROAS
Return on ad spend: revenue credited to ads divided by what the ads cost.
Technical
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.
- rug-level
- see rugged
- rug pull
- see rugged
- rug-pulled
- see rugged
- rugged
Crypto slang: when the people behind a project walk away with the value, leaving the community holding the losses.
Borrowed and redefined
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.
S
- 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.
Proprietary
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.
- schema
The declared structure of stored data: which fields exist, their types, and how records link. It sets the questions you can ever ask.
Technical
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.
Technical
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.
- service angle
- see three-angle valuation
- Seven Layers Deep
My rule that every diagnosis digs seven layers below the complaint a client opens with before I recommend any deliverable.
Coined
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.
- 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.
Borrowed and redefined
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.
- seven-sins discipline
- see seven sins
- 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.
Coined
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.
- shared floor
- see The Floor
- 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.
Coined
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.
- slop
Generic machine-written content: grammatically clean, plausible, and written for nobody in particular.
Borrowed and redefined
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.
- software angle
- see three-angle valuation
- Solana
A public blockchain known for fast, cheap transactions. Several Looikos brands and my tokenomics work are built around it.
Technical
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.
Technical
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.
- 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.
Coined
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.
- Standard Model
- see Standard Model of Effective Media
- Standard Model essay
- see Standard Model of Effective Media
- 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.
Coined
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.
- standard operating procedures
- see SOPs
- 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.
Coined
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.
- STORM
A Stanford research method for AI writing that grounds every claim in retrieved, cited sources.
Technical
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.
- STORM-inspired
- see STORM
- 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.
Proprietary
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.
- streaming data mesh
- see data mesh
- stylometric
- see stylometry
- stylometry
Measuring a writer's style with numbers: sentence lengths, punctuation, vocabulary variety and how often small function words appear.
Technical
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.
- 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.
Borrowed and redefined
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.
- suffering loop
- see cycle of suffering
- SuperHarness
My brand for engineering the systems around AI agents: I teach the discipline, release open-source plugins, and sell custom buildouts.
Proprietary
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.
- Symphony AGI
The earlier name for my agent system and the brand built on it. SuperHarness has since replaced it as the brand.
Proprietary
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.
- Symphony AGI harness
- see Symphony AGI
T
- TAM
Total addressable market: the full revenue available if a product won every possible customer in its market.
Technical
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.
- temporal knowledge graph
- see knowledge graph
- temporal metagraph
- see metagraph
- 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.
Borrowed and redefined
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.
- test budget framework
- see test budget
- 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.
Coined
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.
- The Loop Engine
- see Loop Engine
- the mesh
- see data mesh
- The Shape of Data
- see Shape of Data
- 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.
Borrowed and redefined
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.
- three-angle model
- see three-angle valuation
- three-angle read
- see three-angle valuation
- three-angle thesis
- see three-angle valuation
- three-angle valuation
Valuing every Looikos brand from three sides at once: finance, software and service.
Coined
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.
- three-level read
- see market-maker read
- token bill
- see tokens
- token cost
- see tokens
- tokenomics
The economic design of a crypto token: supply, distribution, incentives, and how value moves between holders and the project.
Technical
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.
- 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.
Technical
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.
- tokens a model reads
- see tokens
- tokens per
- see tokens
- total addressable market
- see TAM
- total value locked
- see TVL
- turbulent surface
- see laminar depth
- TVL
Total value locked: the total amount of crypto deposited in a decentralized finance platform.
Technical
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.
- type-safe
- see typed
- typed
Data with a declared shape: every field has a fixed type that code checks, so bad values fail loudly at the boundary.
Borrowed and redefined
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.
- typed citations
- see typed
- typed contract
- see typed
- typed data
- see typed
- typed edges
- see typed
- typed models
- see typed
- typed nodes
- see typed
- typed object
- see typed
- typed passes
- see typed
- typed Pydantic models
- see Pydantic
- typed relationships
- see typed
- typed schema
- see typed
U
- 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.
Coined
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.
- unified decision framework
- see policy-first
V
- valuation comps
- see comps
- 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.
Coined
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.
- value rubric
The scoring method that ranks every Looikos brand and capability against the others to set what gets built first.
Borrowed and redefined
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.
- vector embeddings
- see embeddings
- Vector Engineering
Shaping what an AI system draws on when it answers, so questions about your business get answered from your real material.
Coined
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.
- Velvet Rope
My qualification system: marketing, intake and calls built so wrong-fit prospects disqualify themselves before they ever see a price.
Borrowed and redefined
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.
- VoC
- see voice-of-customer research
- 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.
Coined
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.
- Voice Fingerprint
A numeric profile of how one business writes, measured from its own copy, so drafts can be checked against its real voice.
Coined
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.
- Voice Fingerprint Deliverable
- see Voice Fingerprint
- voice of customer
- see voice-of-customer research
- voice-of-customer research
Research that collects how customers describe their problems in their own words, from reviews, calls, forums and support tickets.
Technical
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.
W
- Wardley evolution
- see Wardley map
- 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.
Technical
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.
- Wardley mapping
- see Wardley map
- Wardley read
- see Wardley map
- Wardley Swarm
A planned Looikos brand where AI agents build an evidence-backed strategic map of a situation and simulate moves across it.
Proprietary
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.
- WikiDesignCo
My data-platform lab: the knowledge platform holding the metagraph every other brand reads from, also rented to clients on a flat retainer.
Proprietary
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.
- world model
A living, queryable model of a business, market or domain that agents read before acting and update as the evidence changes.
Borrowed and redefined
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.
The flagship Looikos agency: a technical marketing agency that models a client's market in software, then runs the story across every channel.
Proprietary
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.