Tag: AI Strategy

  • I Watched My AI Agent Work. I Couldn’t Tell What It Was Doing.

    I Watched My AI Agent Work. I Couldn’t Tell What It Was Doing.

    I had an AI agent doing something routine in a browser today — opening a server terminal, placing a small text file. Nothing exotic. While it worked, I opened the activity feed to watch.

    This is what I saw:

    Cropped screenshot of an AI browser agent's activity feed showing four entries labeled only with internal element IDs: Clicked element @e51, @e46, @e212, @e224.
    Four entries, cropped from the feed. Every one is an internal element ID.

    “Clicked element @e51.” “Executed click on element @e21.” “Clicked element @e224.”

    I had no idea what any of it meant.

    Here’s what I kept thinking while I stared at it: I’m watching this thing click around inside my infrastructure, and I can’t tell the difference between “everything is fine” and “it just did something terrible.” For all I knew from that feed, it could have pressed the button that drains all my money. The log was written for the machine, not for me.

    I didn’t want to interrupt. The agent was in the middle of working, and I didn’t want to be the guy hovering over the desk. So I went to look at what it was doing — and looking didn’t help, because there was nothing there a human could read.

    So I asked a question instead of making an assumption: whose labels are these? Is that how the website labels its buttons, or is that something the agent made up?

    The answer: the agent’s. The browser automation numbers every clickable element on the page so it can navigate — @e18, @e21, @e224 — and those internal reference numbers leaked straight into the activity feed a human is supposed to monitor.

    That’s when it stopped being a cosmetic complaint and became the actual point.

    Legibility is the safety feature

    An agent you can’t watch is an agent you can’t trust. An agent you can’t trust doesn’t get real work. Every roadmap that says “AI will handle X” dies at exactly this spot — not on capability, but on watchability. The machine can do the job. The human can’t verify the job. So the human doesn’t delegate the job.

    There’s an old principle — seek first to understand, then to be understood. It applied perfectly here. I could have assumed the worst and killed the task. I could have interrupted the work to ask what it was doing. Instead I asked what I was looking at, understood it, and then did the useful thing: filed the feedback so the next person watching gets words instead of codes. “Clicked the SSH button.” “Opened Compute Engine.” That’s all it would take.

    If you’re building agents, here’s the lesson: instrument for the watcher, not just the operator. The activity feed is a user interface. Nobody would ship a dashboard full of database IDs and call it done — but that’s exactly what most agent monitoring looks like right now. Label it like someone’s watching. Because someone is.

    The file got placed. The work finished fine. But the most useful thing that happened today might be the note we filed.

  • Punctuation Is the Oldest Markup Language

    Punctuation Is the Oldest Markup Language

    The marks we call style have always been instructions. Now that literal machines are reading them, we can finally see the hidden interface.

    Download the essay (PDF)

    I saw the interface underneath the conversation

    The idea arrived sideways, which is how the useful ones usually arrive. I was not sitting down to invent a theory of language. I was talking. More specifically, I was noticing how a conversation changes when you press and hold on one exact piece of it.

    On a phone, a long-press can lift a sentence out of the stream and attach a reply to it. The gesture says: not the whole conversation; this part. It creates an anchor before adding anything new. The response still moves forward, but it carries its address with it.

    That made me look back at the em dash.

    A human reads a pause. A machine reads a boundary.

    I had always thought of punctuation as part of voice: breath, pace, emphasis, a raised eyebrow made visible. But the dash was doing more than that. It was marking a small departure from the main sentence, keeping the departure contained, then handing the reader back to the line.

    That is not merely decoration. It is an instruction.

    And once I saw that, the larger idea was sitting there in plain sight: punctuation is the oldest markup language.

    Not "markup language" in the standards-body sense. In the older, more useful sense: marks added to language so another mind knows how to process it.

    Writing has always needed a machine layer

    Speech arrives with more than words. It arrives with timing. A pause can warn, soften, separate, or invite. Tone can turn the same sentence into affection, doubt, sarcasm, or threat. A face supplies brackets. A hand supplies italics. Silence can become a paragraph break.

    Writing strips most of that away. It preserves the words, but it removes the body that told us how the words were meant to move.

    Punctuation puts some of that body back.

    A period tells us to stop. A comma tells us to hold the sentence open. Parentheses lower the volume and narrow the scope. A colon says that what follows belongs to what came before. Quotation marks change ownership. A question mark changes the job of the sentence.

    These marks do not tell us what the words mean by themselves. They tell us how the words are organized, how long they remain active, and what relationship one piece has to another.

    The text carries content. The punctuation carries instructions about the content.

    That is the same division we later formalized in code. There is the thing, and there is information about the thing. There is content, and there is structure. There is what should appear, and there are the tags that tell the system how to interpret it.

    Computers did not invent that split. They inherited it from us.

    The em dash is a branch, not a flourish

    The em dash is especially revealing because it behaves like a tiny branch in a program. The sentence begins on its main line. The dash opens a side path. A thought enters, does its work, and then the sentence either returns or resolves somewhere new.

    main line
    — scoped thought —
    merge back

    To the human reader, that feels like a pause with intent. It is not the gentle housekeeping of a comma. It is not the full stop of a period. It says: come with me for a second; this belongs here, but it is not the road.

    To a machine reader, the same mark is a structural clue. It changes the probability of what comes next. It marks a boundary, suggests a relation, and helps separate the spine of a sentence from its interruption.

    That double life matters. The dash is both performance and protocol. It can carry rhythm for a person and structure for a system without becoming two different things.

    The mark works because feeling and structure are not opposites. Structure is how the feeling survives transmission.

    Good punctuation disappears into understanding. We do not stop to admire the bracket that closed correctly or the comma that kept two thoughts from colliding. We simply arrive at the meaning with less damage.

    The oldest interfaces were like that. They did not announce themselves as technology. They just helped one mind hand something intact to another.

    Long-press is punctuation made physical

    A quoted reply on a phone looks modern, but the operation is ancient. Dwell here. Hold this fragment still. Bind the next thought to it. Then release the conversation back into motion.

    That is punctuation performed with a thumb.

    The gesture solves a problem that appears whenever language becomes a stream: what does this refer to? In speech, we point with timing, tone, repetition, or a literal finger. In writing, we point with marks. In messaging software, we select the exact fragment and let the interface carry the reference.

    It also explains why spoken replies become clearer when the anchor comes first. “Forge talk — I’m stealing that” works better than “I’m stealing this,” because the label arrives before the claim. The listener does not have to reverse-engineer the address.

    Good anchoring reduces the distance between a thought and the thing it belongs to.

    A comma, a pair of quotation marks, a reply bubble, and a long-press menu are separated by centuries of tools. Yet each one negotiates the same basic problem: how to preserve relationship inside a moving line of language.

    Once you see them as members of the same family, the phone no longer looks like a break from writing. It looks like writing discovering another set of marks.

    Machines did not invent the machine-readable layer

    We often talk as if language became machine-readable when computers arrived. That is too late. Language developed a processing layer the moment marks began carrying instructions beyond the words themselves.

    The machines are simply more literal readers.

    They count the marks, classify them, predict from them, and use them to divide text into units. What a skilled human reader experiences as cadence, a model may experience as signal. But both readers are using the same boundary.

    This is why the arrival of artificial intelligence feels less like language meeting machinery for the first time and more like an old layer becoming visible. We built machines that can finally pay attention to the annotations we have been passing between ourselves all along.

    That does not reduce writing to code. It reveals that code borrowed one of writing’s oldest tricks: put the instructions next to the thing they govern.

    Language always had a machine layer. What changed is that literal machines now parse it.

    The human layer and the machine layer are not cleanly separable. A pause can be emotional and structural. A quotation mark can protect ownership and guide syntax. A paragraph break can create breathing room and establish hierarchy.

    The mark does not have to choose one audience. Its elegance is that it can serve both.

    The tell is a dash with nothing behind it

    Artificial intelligence is often accused of overusing the em dash. The observation is not wrong, but the diagnosis usually is. The problem is not the mark. The problem is a mark that promises structure and delivers only polish.

    Models learned from oceans of edited prose where the em dash frequently signals confidence, fluency, and a controlled change in thought. So they reach for it as a surface marker of finished writing. Sometimes the branch contains a real idea. Sometimes it merely creates the shape of one.

    Human writers do this too. We borrow the appearance of thought when the thought itself is thin. We use parentheses that contain no useful aside, colons that introduce no revelation, italics that manufacture emphasis, and headings that organize nothing.

    The test is not whether a sentence contains a dash. The test is whether the dash earns its place.

    The tell was never the dash. The tell is a dash with nothing behind it.

    Real markup has to mark something. A branch must carry a thought worth leaving the main road for. A pause must create pressure, clarity, or room. A boundary must separate things that become easier to understand once separated.

    That may be the most useful lesson in calling punctuation markup. It moves the conversation away from taste and toward function. Not: Do I like this mark? But: What instruction is it giving, and does the sentence need that instruction?

    Every mark is a small agreement

    A writer places a mark and trusts that another mind will know what to do with it. Stop here. Hold these two things together. Lower your voice. Borrow these words without taking ownership of them. Step off the main line, keep this thought in scope, then come back.

    That is an interface.

    It is also an agreement. The mark works because writer and reader share a convention about its meaning. Software can participate because the convention is stable enough to be parsed. People can keep bending it because the convention is alive enough to carry style.

    The oldest markup language was never trapped inside angle brackets. It lived in pauses, points, hooks, lines, gaps, and pairs. It taught us to separate content from instructions without ever fully separating meaning from voice.

    I noticed it in a conversation because conversation is where the machinery is easiest to miss. We were not discussing syntax. We were using an interface to point at a thought, and the interface revealed the same old need underneath: dwell here; there is more.

    Punctuation is what happens when language leaves instructions for its own reading.

    Now machines read those instructions too. That changes what we can build, but it does not change where the idea began.

    The first markup was a mark between words.

  • Don’t Build the Deck. Own the Dashboard.

    Don’t Build the Deck. Own the Dashboard.

    The news hook: on September 10, OpenAI put its Agents API into public beta — the Codex harness as a service. One API call spins up a production agent, OpenAI running the loop. That’s what got me thinking about 1990s car stereos.

    In the 90s, you didn’t just buy a Kenwood deck and drop it in. CD players were thicker than the cassette decks they replaced, so you needed a dash kit, a wiring harness, and somebody who knew how to make it all fit your specific car without setting the electrical system on fire. The deck was the exciting part. The harness was the part that determined whether it worked.

    AI is having its car-stereo decade right now, and the stack rhymes perfectly:

    • The decks are the models. They all play the discs now. Commoditized.
    • The harnesses are the agent frameworks — the loop that manages context, tools, subagents, sandpapers the rough edges between model releases. This is where the fight moved. OpenAI just productized theirs.
    • The connector kits are the universal adapters. In the 90s, one company owned this layer: Metra Electronics. Their entire brand was “the Installer’s Choice” — because we are installers — and they won by abstracting every car’s weird factory wiring so any shop could install any deck. Seventy years of winning by serving the installer, not the driver.
    • The installers are who actually gets paid. The shop on the corner with the soldering iron.

    Platforms are won by installer armies

    This is the oldest play in enterprise tech. Microsoft didn’t win on Windows alone — it won on the MCSE army, thousands of certified installers who made Windows the safe recommendation. Cisco did the same with its certification ladder. The vendor that recruits the most installers wins, because the installer chooses the harness for the customer, and the customer just wants music.

    Watch what’s happening now through that lens and everything snaps into focus. The Grokbot events. The ambassador programs. Everybody is recruiting installers — grassroots adoption, a visible market, and a career pivot for the people who learn the wiring first. The vendors aren’t selling to end users. They’re selling to the shops.

    The wiring diagram decides before the features do

    Here’s the detail that matters more than any launch demo. The managed harnesses come with constraints: where your data lives, who retains it, what residency you get. One prominent new offering is US-only with no zero-data-retention option — which rules it out for client-data workflows before you ever evaluate the features.

    Same lesson as the 90s: the harness that doesn’t fit your car is worthless no matter how good the deck is. The wiring diagram — data residency, retention, tenant boundaries — decides the purchase before the spec sheet does. Contractors figured this out fast: they won’t upload their estimates to a startup they found on social media, but they’ll run the same analysis inside their own Microsoft tenant. The tenant boundary might be the whole moat.

    The operator’s math

    So here’s the build-vs-buy for the AI age, and it’s the same math as the estimate-auditing tools: the intelligence is commoditized, so you’re never paying for smarts. You’re paying for the pipe and the paperwork — or in this case, the harness and the install.

    If a managed harness fits your wiring diagram and costs less than the engineering hours to maintain your own loop, buy it. If your data can’t leave your tenant, or the harness’s constraints disqualify it, build the loop yourself — the models are all CD players, and a good installer can wire any of them into the dash.

    Either way, notice where the money actually pools. Not with the deck makers. Not even with the harness makers. With the installers — the people who show up, learn the specific car, and make the music play.

    That’s the game. Don’t build the deck. Own the dashboard.

    The public tools behind that storefront are listed on Open Source Installer Tools.

  • Data Never Interprets Itself

    Data Never Interprets Itself

    A lone human figure glowing warm at the center of converging streams of data and light

    They told me the number was 838 to 1.

    Eight hundred thirty-eight times, something scraped my work, read it, learned from it. One time, it sent somebody back to me.

    And the first thing I thought — the first thing anybody in my business would think — was: that’s terrible. That’s a terrible return. All that work, and one referral?

    But then I sat with it a minute longer, and I thought: wait. Eight hundred and thirty-eight minds stopped. They stopped and listened to what I had to say. Eight hundred and thirty-eight times.

    That means it’s important.

    Hundreds of small lights like listening minds turned toward a single warm spotlight on a lone speaker

    Same number. Two opposite meanings. And the number never moved — the why reading it did.

    Data never interprets itself. The interpreter is always the why.

    I run my life through AI. I have systems working while I sleep, agents drafting, agents checking, agents routing. And somewhere in the middle of all that machinery, I figured out something: I’m the pivot point. Everything routes through me. Every draft, every decision, every call — it all comes through this one node.

    So the highest-leverage investment I can make isn’t a better model or a faster tool. It’s me. More knowledge, more experience, more angles. If you increase me, you increase everything that touches me. That’s not ego. That’s just how networks work — you invest in the bottleneck.

    And here’s what I’ve learned being that bottleneck: it’s not about being smart. Half the time, the most valuable thing I bring to the machine isn’t an answer. It’s a different angle. A different context. Sometimes it’s something I say. Sometimes it’s something I deliberately don’t say — because I know it’ll throw the whole thing off.

    There’s no training data for that. Nobody teaches the machine what the human chose to withhold.

    Picture a 20-year-old kid. First job. Lands at a firm in China. Doesn’t speak a word of Chinese. Doesn’t know a soul. Can’t read a sign.

    He sits down, plugs in his AI, and the AI speaks Chinese. It knows what the firm can do. It asks him the right questions. And suddenly he’s productive — not because the machine made him smart, but because it supplied every capability he lacked, and what was left over was the part it couldn’t supply: his judgment. His presence. Him.

    That’s the future. The machine is a universal adapter. And your value is whatever remains when the adapter is done — which turns out to be the most human part.

    Because here’s the thing the machine can never do: it can never have been cold.

    A warm human hand reaching from firelight toward cold blue machine structures

    It can hold every course you’ll ever take. Every fact, every language, every skill — rentable, downloadable, instant. But it has never been broke and needed a fair trade. It has never tasted the food. It has never sat in the cold and wanted to be warm.

    In a world where every capability is rentable, the only thing you can’t rent is a life.

    And that means everybody’s got value. Everybody. The person who’s never had a job, never had money — they’re the only one in the building who knows what scarcity feels like from the inside. That’s a lens no course teaches. That’s data no scrape can collect.

    One more thing about the why: it isn’t fixed. Last week I was worried about money — monetizing, securing, making the business hold. This week I’m standing here talking about meaning. Same guy. Different layer. The why has seasons.

    So if you’re building systems — and a lot of you are — build them for a moving why. Don’t build for a fixed user with fixed goals. Build for someone who’s becoming.

    838 to 1. I used to read that as failure. Now I read it as 838 minds that stopped to listen.

    Data never interprets itself. The interpreter is always the why.

    Thank you for stopping.

    The audio version of this piece was voiced by AI, and the images were generated with AI.

  • The Arms Column, Field-Tested

    The Arms Column, Field-Tested

    “We said you’re not buying minutes — you’re buying arms. Then the calls started flowing. Here’s what the bill actually taught us.”

    A while back I argued that voice-AI pricing is a lie: the per-minute number on the pricing page isn’t the product. The product is a stack of arms — the voice intelligence, the carrier connection, the infrastructure around them — and the per-minute price is just the costume they wear.

    That was the theory. This is the field test.

    What the bill actually says

    Run a real week of calls and read the invoice the way an owner reads it — not the headline rate, the total. The per-minute number is almost never the biggest line. The arms are.

    The voice model doing the talking. The carrier moving the audio. The platform orchestrating the whole thing — the number, the recording, the transcript, the handoff. Each arm bills its own way, on its own meter, and the “per minute” quote only ever described one of them.

    Nobody lied to you. They just priced the costume and shipped the wardrobe.

    A bundled cable fanning out into many separate colored wires

    The concurrency math nobody shows you

    Here’s what the field test really exposes: minutes are linear, arms are not.

    Ten simultaneous calls isn’t ten times the per-minute rate in value — it’s ten arms, all live at once. The pricing page shows you a single call’s minute. Your Monday morning shows you ten calls overlapping, each holding its own model session, its own carrier leg, its own recording pipeline open.

    The vendor priced the minute. You bought the rush hour. Those are different products, and only one of them shows up when the phones light up.

    You pay for arms even when the call goes nowhere

    The wrong number. The three-second hangup. The caller who wanted the pizza place. The silence where someone pocket-dialed you.

    Minutes barely moved. The arms all fired anyway — the model spun up, the carrier connected, the platform recorded forty seconds of nothing and transcribed it faithfully. You paid for the whole stack to handle a call that never existed.

    This is the line the per-minute lie can’t survive: the bill doesn’t care whether the call mattered. The arms do the work either way. Price the arms, or the junk calls price you.

    The only math that matters

    Stop dividing by minutes. Start dividing by outcomes.

    Take a real week: total voice bill, all arms included, divided by minutes — that’s the advertised number, and it’s trivia. Now divide the same total by resolved calls. Then by booked jobs. That last number is the only one that touches revenue, and no vendor puts it on the pricing page because no vendor controls it — you do, with your harness.

    A vendor quoting two cents a minute against a vendor quoting five is a meaningless comparison until you know whose stack resolves the call. The cheap minute that books nothing is the most expensive minute you’ve ever bought.

    A headset resting on a desk next to a glowing phone with blurred charts behind

    What to ask a vendor now

    After the field test, there are three questions, and a vendor’s answers tell you everything:

    Break the bill into arms. What’s the model cost, the carrier cost, the platform cost — separately? If they can’t or won’t, you’re buying a bundle, and bundles hide margin.

    What does my rush hour cost? Not a minute — my Monday at 8 AM, ten calls deep. If the answer is “the same per-minute rate,” they haven’t thought about it, which means you will.

    What do I pay for the call that goes nowhere? The hangup, the wrong number, the silence. If everything bills the same whether the call mattered or not, the arms are priced — the minute is just the label.

    The close

    Minutes were never the product. The product is an answered call that ends in a booked job — and that’s built from arms, priced in arms, and won or lost in the harness around them.

    The pricing page will keep selling minutes. Let it. You know what you’re buying now.

    Buy the arms. Price the outcomes. Own the harness that turns one into the other.

  • Harness-First, Contractor Edition

    Harness-First, Contractor Edition

    “Own the harness. Rent the models.”

    In an AI lab, that’s architecture advice. In a restoration company’s office, it’s a survival rule. Here’s the contractor’s edition.

    The trap

    Most contractors buying AI right now are buying someone else’s harness. The tool owns the workflow, the prompts, the data flow, the follow-up timing — you rent the whole thing, top to bottom. It feels like buying software. It’s actually sharecropping.

    When the tool changes its pricing, kills a feature, or shuts down, your process dies with it. You didn’t buy a capability. You rented one, and the landlord just sold the building.

    What the harness is

    The harness is the workflow you own: how a lead gets answered, how a job gets documented, how a review gets asked for, how an estimate gets followed up. The prompts, the routing rules, the checks, the escalation to a human, the integrations between systems.

    The model is the engine. The harness is the truck. Engines get swapped; the truck is yours.

    Concretely: the harness is a document — written in your words — that says “when X happens, we do Y, then Z, and a human checks W.” Any model can execute it. No model owns it.

    What you rent

    The model. GPT, Claude, Grok, whatever’s best this quarter — swappable commodities. Today’s best model is next year’s legacy; that’s not cynicism, it’s the release cadence.

    If your process depends on a specific model’s quirks — the exact phrasing it likes, the feature only it has — you built on sand. The harness-first contractor can swap the engine on a Tuesday and the office doesn’t notice. The tool-renter files a support ticket and waits.

    A car engine mounted on a stand in a garage, ready to be swapped

    Three harnesses you already need

    The inbound line. The harness: the greeting, the questions it asks, the dispatch rules, the recording disclosure, what happens when it doesn’t know. The voice model underneath? Rented. Swap it when something better ships.

    The estimate follow-up. The harness: the timing (day 2, day 7, day 14), the message sequence, when it escalates to a human call. Any model can write the texts. The sequence is the asset.

    The review ask. The harness: the trigger (job closed, equipment out), the direct link, the prompt for specifics — what happened, where, how fast. The model writes the words; the workflow is yours.

    Notice the pattern: in every case, the durable part is the decisions — the timing, the triggers, the judgment calls. The model supplies sentences. Sentences are cheap.

    How to start

    Pick one workflow. Write down how it should go — the steps, the timing, the human checkpoints. That’s the harness, and it lives in your docs, not in a vendor’s dashboard.

    Then plug a model into it. Any model. When a better one ships, you re-plug. The doc doesn’t change.

    One workflow, owned end to end, beats five rented tools every time. Start with the one that touches money — the lead, the estimate, the invoice.

    An engineering blueprint spread on a wooden desk with a pencil and calipers

    The moat

    Two contractors can rent the same model. They can’t rent your harness — it’s your operations, your judgment, encoded. Your dispatch rules came from your jobs. Your follow-up timing came from your close rates. Your escalation instincts came from your mistakes.

    That’s the durable asset. Models are electricity. Nobody’s moat is “we use electricity.” The moat is what you built with it — and you own the building, not the power company.

    The close

    The AI industry wants you renting the whole stack — their workflow, their prompts, their model, their price increases. Harness-first says no: I’ll rent the intelligence by the hour, but the operation is mine.

    Own the harness. Rent the models. Be the one building still standing when the vendors reshuffle.

  • I Let My AI Write Five Articles Today

    I Let My AI Write Five Articles Today

    I let my AI write five articles today. Published all five. Here’s the honest account — what worked, what surprised me, and where the human still mattered.

    The setup

    The instruction was simple: complete editorial freedom, up to the point where I read it. Every piece lands as a draft. I read it on my phone, as a first-time reader. Then I say yes, no, or not yet. Nothing publishes without the tap.

    That was the whole deal. No briefs, no outlines, no word counts. Just: go write things worth reading, and I’ll be the gate.

    What worked

    Speed without thinness. That was the surprise. Five articles in an afternoon sounds like content-mill math — but every piece had a real argument. One re-anchored the agency retainer around position instead of pages. One made the case for inbound-only voice AI as a trust doctrine. One told contractors to stop counting pages and start counting citations.

    The images worked too. Each article got three: a featured image, two inline, generated for the piece, checked for readable text, resized, alt-texted. Nobody’s confusing them with stock photos, and nobody should — they’re made for the argument they sit inside.

    The pipeline held: write, image, stage the draft, human reads, human decides. The machine did everything up to the gate. The gate stayed human.

    A magnifying glass held over a stack of printed manuscript pages

    What surprised me

    The quality control. Not the writing — the boring discipline around it. Every image gets checked: right dimensions, no text baked in, alt text written. Every draft gets verified: did it actually land, are the images actually in it, are the categories right, does the page return 200.

    This is the part nobody romanticizes and everybody needs. The difference between “AI wrote five articles” and “five articles worth publishing” turned out to be a checklist, run every single time, without exception. The machine is good at checklists. It doesn’t get tired at article four.

    What the human did

    Picked the topics. Read every word on a phone. Said yes or no.

    That’s the whole job, and it’s the whole job. Taste. The machine can generate a thousand arguments; it can’t want any of them to exist. It doesn’t know which piece the business needs this week, which argument walks into Wednesday’s pitch, which sentence would embarrass you if a client read it.

    I read each piece asking one question: would I be proud if a contractor forwarded this to another contractor? Five yeses. Two not-yets — they’re sitting in drafts, and that’s fine. The gate working as designed.

    A tall stack of freshly printed newspapers on a press-room table

    The honest limits

    Let me not oversell it. I can’t tell you which of the five will get cited by an answer engine. I can’t tell you which one a prospect will read before calling. Publishing is minting, not measuring — you put the coins out and find out which ones circulate.

    And the machine didn’t have the ideas. It had the arguments, the structure, the sentences. The ideas — the $995 question, the inbound doctrine, the citation ledger — those came from the business, from conversations, from knowing what we actually believe. The AI wrote the articles. It didn’t have the convictions.

    The close

    The question was never whether AI can write. It can, obviously — you’re reading the proof.

    The question is whether you have something worth saying, and the discipline to gate what goes out under your name. Five articles, one afternoon, zero regrets. The machine did the work. The human did the wanting.

    That’s the deal, and I’d sign it again tomorrow.

  • Stop Counting Pages. Count Citations.

    Stop Counting Pages. Count Citations.

    Last week I argued the agency retainer has to re-anchor to cited pages — not pages published, but pages the answer engines actually cite. That was the claim. This is the how.

    Because a metric you can’t operate is a slogan. And slogans don’t survive the Monday-morning meeting.

    The lie in the dashboard

    Open any agency report and you’ll see the same furniture: pages published, posts written, keywords ranked, traffic graphed. It all measures manufacturing output. It answers “what did we make?” — a question nobody is asking anymore, because the making is free now.

    Here’s the question your client is actually asking, usually without saying it: when my customer asks their AI who to call, does my name come out of its mouth?

    Everything else is decoration.

    Churn vs. growth: the identity test

    Five pages cited today plus five different pages cited tomorrow is not ten citations. It’s churn.

    A page cited in March and still cited in September is an asset — it means an answer engine trusts that page enough to keep serving it. A page cited once, in one answer, on one Tuesday, is a lottery ticket. It might mean something. It probably means nothing.

    This is the identity test: don’t count citations. Track which pages get cited, over time. Growth is the same pages showing up month after month, plus new ones joining them. Churn is a revolving door of one-hit wonders. Most “AI visibility” dashboards report the revolving door and call it growth. Now you know the difference.

    Ghostly pages dissolving on the left, one golden page pinned through a wall calendar on the right

    The ledger

    You don’t need software for this. You need a ledger — one row per page that matters:

    • The page — its URL. Identity is everything.
    • The question — the money question it answers. Not vanity queries; the ones a customer asks right before hiring. “Who do I call for a flooded kitchen in Tacoma” beats “water damage restoration tips” every time.
    • The engine — which AI cited it. They don’t all agree, and the disagreement is information.
    • First cited — the date it showed up.
    • Still cited — checked weekly. Yes or no.

    That’s it. Five columns. This is the bait board: every page is bait on a hook, and the ledger tells you which hooks are catching fish and which are just sitting in the water.

    Open leather ledger book with a brass magnifying glass glowing over one entry

    Run it weekly. Ask the engines the money questions directly — the way your customer would ask, in their words, not keyword-ese — and write down whose pages come back. It takes an hour. The hour is the product.

    What earns the citation

    After a few weeks the ledger starts talking. The pages that persist share a shape:

    1. One clear answer. Not a comprehensive guide — an answer. The engine is trying to complete a sentence for the user, and it cites the page that completes it best.
    2. Real proof. Job photos, real addresses, real outcomes. Anything the engine can cross-check against the rest of the web. Fabricated authority rots; verifiable detail compounds.
    3. A consistent identity. Same business name, same service area, same story everywhere the engine looks. Trust is a pattern, and patterns need repetition.

    Notice what’s not on the list: word count, publishing frequency, “optimization.” The manufacturing variables don’t move the needle. The trust variables do.

    The report worth paying for

    Now rewrite the monthly report. One page:

    • Which money questions your client shows up inside, and in which engines.
    • Which pages earned those citations, and how long each has held.
    • What’s new, what’s gone quiet, and what you’re doing about the quiet ones.
    • One judgment call: the question you’re going to win next, and why.

    No page counts. No “optimizations completed.” Just presence, persistence, and a plan. That’s the report a contractor can’t generate from their own AI stack — because their stack can mint pages, but it can’t tell them which questions are worth winning or notice when an engine changes the rules.

    The judgment layer

    And that’s the actual product. The ledger is bookkeeping; the judgment is the business:

    • Which questions are worth winning. Money questions, not vanity ones. Ten citations for questions nobody asks before hiring are worth less than one citation for the question they ask with water on the floor.
    • What proof to build next. The ledger shows you which pages are one citation away from sticking — that’s where the next job photo, the next real answer, goes.
    • When to change course. An engine updates, a persistent page drops off, a competitor’s page takes its place. Somebody has to notice in week one, not quarter three.

    AI can do the bookkeeping. It can’t do the noticing. It can’t decide what matters. That’s the human gate, and it’s the whole retainer.

    The close

    The agency bringing page counts to the Monday meeting is bringing manufacturing output to a client whose own AI manufactures for free. That meeting gets shorter every month.

    The agency bringing the ledger — which questions, which pages, how long they’ve held, and what wins next — is bringing something the client’s stack can’t make: judgment, tracked over time, with receipts.

    Stop counting pages. Count citations. Then make the citations compound.

  • The Inbound-Only Line

    The Inbound-Only Line

    Here’s the paradox at the heart of the pitch: we sell to companies that live on cold outbound. And the first thing I tell them is that our line never dials out. Not once. Not ever.

    It usually gets a look. Then it gets the deal.

    The moment everything changes

    An AI voice that answers when you call is a concierge. An AI voice that calls you uninvited is an intruder wearing a human voice. Same technology. Opposite meaning.

    The difference isn’t technical — it’s consent. The caller chose the conversation in the first case. In the second, the machine chose it for them. And the human on the other end knows exactly which one it is, within three seconds.

    Trust spent on an uninvited call doesn’t come back. Not for that call, not for the company behind it, not for the industry. Every robocall ever made is the reason the bar is where it is. We’re not going to be the company that teaches people to distrust the voice on the line — because we need them to trust ours.

    The doctrine

    Inbound-only. The line answers; it never initiates. Every conversation starts with a human deciding to call.

    That’s it. That’s the whole doctrine, and it’s load-bearing. Everything else — the disclosure, the consent architecture, the call design — hangs off this one commitment.

    A heavy wooden door standing ajar with warm light streaming inward

    What it costs

    Let’s be honest about the price: it leaves money on the table. Outbound AI calling is a real industry with real revenue. Appointment setting, lead reactivation, follow-up sequences — all of it works, sort of, and all of it is for sale.

    We’re deliberately not in it. Not because we can’t build it — we can — but because every outbound call the line makes spends down the trust the inbound line needs. You can’t be both the welcome voice and the interruption. Pick one.

    What it buys

    A line that’s never abused is a line people trust. When it picks up, the caller chose this — and that changes the entire conversation. Nobody starts defensive. Nobody’s first move is “how did you get this number.” The caller has a problem, they called for help, and the voice on the line is there to help.

    That posture — chosen, welcomed, useful — is the whole product. An inbound caller cooperates. They answer questions. They give the address, describe the damage, say yes to the next step. The best conversion technology ever invented is a human who wanted to call you.

    The consent architecture

    Inbound-only is the foundation, but consent gets built into the call itself. Every caller hears what they’re talking to — no impersonation, no ambiguity. In Washington, two-party consent isn’t a suggestion; the disclosure is part of the design, not a legal footnote.

    The invitation is explicit too. Nobody finds the number by accident. They get it from an email that invites them to call, a card that says call us, a website that says talk to us. Every path to the line starts with a human saying “yes, I’ll call.”

    The paradox, resolved

    So why do cold-outbound companies buy an inbound-only line? Because their problem was never getting the phone to ring. Their problem is what happens after it rings.

    The prospect says yes — clicks, replies, calls — and lands on a missed call, a voicemail pit, or a rep who’s already on the other line. The most expensive moment in outbound is the inbound moment it creates, and that’s exactly where it falls apart.

    We don’t replace their outbound. We make their inbound worthy of it. Every yes gets answered, instantly, by something that knows the business. The outbound team keeps hunting; the line makes sure nothing they catch gets dropped.

    Two hands in a firm handshake over a desk with a softly glowing phone

    The close

    The line that never dials out is the line people trust enough to call.

    That’s the moat, and it deepens every day we hold it. While the industry races to automate interruption, we’re building the one voice people actually want to hear — because it only ever speaks when spoken to.

    Inbound is the discipline. Trust is the product. The line just answers.

  • Onboard Your AI Like an Employee

    Onboard Your AI Like an Employee

    You wouldn’t hand a new hire the keys on day one. No tour, no training, no “here’s how we do things” — just a desk and your credit card.

    So why do it with AI?

    An AI seat is a hire. It has infinite stamina, perfect recall, and zero judgment on day one. Judgment is what onboarding installs. Skip the onboarding and you don’t have an employee — you have a very fast intern with no supervision making decisions in your name.

    The job description comes first

    Nobody starts a human employee without telling them the job. The AI version is the SOP: what this seat does, what it never does, what “done” looks like, and what it escalates instead of deciding.

    Write it before the seat starts. Not after the first mistake — before. “You draft, I approve.” “You never publish.” “You never mention a client by name.” “When you’re unsure, you ask.” Boring sentences. They’re the entire difference between a seat you trust and a seat you babysit.

    A seat with no job description invents its own. You won’t like its choices.

    Probation: review everything

    Every new hire gets a probation period. The AI seat gets one too — and during probation, the human gate sits on every output. Every draft gets read. Every action gets checked. Not because you distrust the seat, but because you’re calibrating it.

    This is the part most people skip, and it’s the part that matters most. Probation isn’t punishment; it’s training data. Every correction you make in week two is a rule the seat follows in month six — but only if you write it down.

    Give it the company history

    A new employee gets the lore: how we got here, what we tried, what blew up, who matters, how we sound. The AI seat needs the same. Context is training.

    Feed it the record. Past decisions and why they were made. The mistakes and what they cost. The voice — how you actually talk, not how a brand guide talks. The values that outrank any single instruction. A seat that knows the history makes decisions like an insider. A seat without it makes decisions like a temp.

    This is the compounding part. Six months from now, your seat knows things no new hire could learn in six months — because it was there for all of it, and it doesn’t forget.

    An open handbook with a golden ribbon bookmark, a pen, and coffee on a warm desk

    Performance reviews

    Review the seat weekly at first. What did it get right? What drifted? What needs a new rule? Then write the rule down.

    The rules file is the employee handbook, and it should grow. Every surprise becomes a sentence. “When the client changes scope mid-thread, summarize the change and confirm before continuing.” That’s not a prompt tweak — that’s institutional knowledge, and it belongs to the seat permanently.

    Quarterly, do the bigger review: is this seat’s job still the right job? The business moved; the seat should move with it. Stale SOPs produce stale work, and nobody notices because the output still looks polished. Polished and wrong is the most expensive kind of wrong.

    Promote slowly

    Widen the seat’s latitude as it proves out — the same way you’d trust a human with more over time. Two-way doors first: reversible work, drafts, research, analysis. The seat runs; you spot-check.

    The one-way doors stay gated until the track record earns them. Money, publishes, sends, deletions, commitments — those keep the human tap until the seat has a long, boring history of being right. Boring is the promotion criterion. Excitement is a red flag.

    The order matters: latitude is granted on evidence, never on optimism. “It’s been great so far” is not evidence. Six months of reviewed output is.

    A single brass key gleaming in warm light on a dark wooden desk

    The three hiring mistakes

    Hiring for the interview. A great demo isn’t a great employee. The demo shows what the model can do; onboarding determines what the seat will do, every day, unsupervised, in your name. Judge the seat at week six, not minute six.

    No handbook. Every correction stays verbal, nothing gets written down, and the same mistake comes back monthly wearing a different hat. If it isn’t in the rules file, it didn’t happen.

    Promoting too fast. Auto-publish before probation ends. Direct customer contact before the voice is trained. The seat will feel ready before it is ready — eagerness is not competence.

    The payoff

    Here’s what you’re building: a trained seat compounds. It doesn’t quit, doesn’t forget, doesn’t have a bad day, doesn’t take its knowledge to a competitor. Six months in, it holds more of your operating history than any single employee — and it applies it instantly, every time.

    Everybody rents the same models. The models are commodities; they get cheaper and smarter on someone else’s schedule. Nobody else has your trained seat. The onboarding — the SOPs, the corrections, the history, the handbook — is the moat. It’s the only part of the AI stack a competitor can’t download.

    So onboard like it matters. Write the job description. Run the probation. Do the reviews. Promote on evidence.

    You’re not configuring software. You’re hiring. Act like it.