Tag: AI Agents

  • The Agent-Ready Site: What Kin’s WebMCP Launch Means for Every Business Website

    The Agent-Ready Site: What Kin’s WebMCP Launch Means for Every Business Website

    On October 23, 2026, Kin Insurance became the first U.S. home insurer to enable WebMCP in its quoting experience — an open web standard that lets an AI agent work directly with kin.com, so a homeowner can tell ChatGPT "help me shop for home insurance" and get back a real quote. Strip away the insurance details and what remains is a pattern every business website is about to be measured against: is your site built for the agent your customer sends?

    Most businesses are still arguing about whether to let agents in. Kin skipped that argument. The interesting question is what its launch is made of, layer by layer — because three of the four layers are already visible in our own fleet's numbers.

    Layer 1: Decide to welcome the machine

    Agent traffic is not coming; on our own sites it is already the majority — roughly 62% of visits across the fleet we run are bots and agents, not people. The only choice left is whether that traffic meets a door or a wall.

    Kin chose the door, publicly and in advance: it had already announced that AI shopping agents are welcome on kin.com rather than blocked, naming Meta's Muse among them. The opposite choice exists in the same industry — in September, insurance marketplace Insurify blocked Muse from its comparison platforms, arguing an agent could pull a price stripped of the context that makes it meaningful. Both are coherent positions. What is no longer available is having no position: a site that has not decided is a site whose default settings decide for it.

    Layer 2: Structure the content so a machine can carry it accurately

    An agent can only repeat what it can read, so the agent-ready site is built out of answers, not brochures: one real question per page, paragraphs that stand alone as complete ideas, and structured data underneath that states the facts in machine-readable form.

    This is the layer we work in every day, and it is unglamorous, mechanical work. Tonight, on one operator site in our fleet, we finished putting structured FAQ data — drawn from each page's own questions and answers, verbatim — onto 155 of its 166 articles, because agents cite what is structured and skip what is implied. Multiply that instinct across every page a business owns and you have the content layer of agent-readiness: nothing important lives only in an image, a video, or a sales conversation.

    Layer 3: Give the agent a way to act, not just to read

    WebMCP is the layer most sites do not have yet: the site declares the actions an agent may take — get a quote, with these inputs, in this order — so the agent executes a designed path instead of improvising clicks across a human interface.

    Kin's version is a quote flow, and its testing shows why the layer matters: agents reached a finished quote after asking the consumer only a handful of questions, because the path was declared and the carrier's data filled the rest. The equivalent for any business is the moment a visit becomes a transaction — a booking, a quote, an order. Our own commerce thinking already runs on two rails, one built for humans at a checkout and one an agent can complete; Kin just shipped the insurance version of the second rail, first.

    Layer 4: Measure what the machines do

    Agent-readiness you cannot measure is a vibe. Kin will know whether agents quote it, because the protocol makes agent sessions countable; the rest of us measure the read layer — which pages agents cite, which questions they bring, how the share moves.

    On tygartmedia.com, we track AI citations from our own search-engine exports rather than a vendor's estimate: 1,459,726 citations across 922 cited pages in the October 15 export, up from 269,399 across 324 pages in the September 27 export. Those numbers are the scoreboard for layers 1 and 2. The day an agent can transact here, layer 3 gets a scoreboard of its own.

    Where our fleet honestly sits

    Layers 1, 2, and 4 are running here today — welcome posture, structured content, citation measurement. Layer 3, declared agent actions, is what Kin shipped first, and it is the next build. That is a fair summary of most of the web right now: readable by agents, citable by agents, and still requiring a human to show up for the transaction itself.

    The businesses that treat that gap as a roadmap, rather than a surprise, are the ones whose sites will be ready when their customers stop browsing and start sending.

    Frequently asked questions

    What is WebMCP? An open web standard that lets an AI agent interact with a website through a machine-usable path the site itself declares — no plug-in and no screen-scraping. Kin enabled it in its home insurance quoting experience on October 23, 2026, the first U.S. home insurer to do so.

    What makes a website "agent-ready"? Four layers: a deliberate decision to welcome agent traffic instead of blocking it by default; content structured as standalone answers with machine-readable data underneath; a declared path that lets an agent complete an action, such as a quote or booking; and measurement of what agents actually do on the site.

    Do agents really visit business websites that much? On the fleet we operate, roughly 62% of visits are bots and agents. The share varies by site, but the direction does not: the reader a growing share of your pages serve first is a machine deciding what to show its human.

    Source: Kin Insurance announcement via PR Newswire, October 23, 2026. Fleet figures are Tygart Media's own: bot share from our site analytics; citation counts from our Bing AI Performance exports of September 27 and October 15, 2026.

  • AI Governance Is the Gate That Caught the Thing

    AI Governance Is the Gate That Caught the Thing

    Most AI governance is written by people who have never had to govern an agent that could actually break something. It reads like insurance paperwork: frameworks, maturity models, principles laminated on a wall. Then a real agent, on a real Tuesday, publishes your drafting notes as if they were the article — and the framework has nothing to say about it, because the framework was never in the room.

    We run a small agency where AI agents do real production work every day: research, drafting, publishing, measurement, and an unattended night queue that runs while we sleep. Governance, for us, is not a document. It is the set of gates that have caught real things. Every rule below exists because something specific got past us first, and the rule is the scar.

    Governance starts with who is allowed to remember

    The agents are stateless; the memory lives in one place. Every agent we dispatch starts cold. It knows nothing about our clients, our sites, or yesterday’s decisions until its work order tells it. That sounds like a limitation. It is the control surface. Because the agent holds no standing memory, it holds no standing permissions either — every job is scoped, priced, and bounded by the order that created it, and when the job ends, the access ends with it.

    The work order itself is a governance document. It states the whole price up front, names the points where a human must tap before work proceeds, and lists what the executor may ship directly and what it must hold. An agent that has to ask a question the order should have answered is not a governance failure by the agent. It is a drafting failure by us, and we treat it that way.

    Draw the doors as lines, not policies

    Four things always need a human tap: money, credentials, outbound sends, and publishing. Everything else, the fleet runs on its own. That split is the entire access policy, and it fits in one sentence because it has to survive contact with a tired operator at the end of a long day. Policies that need interpretation get interpreted — usually at the worst moment, in the most generous direction.

    Credentials get the hardest line. Our agents never hold passwords, never see them, never pass them along. Work that reaches a login the agent cannot complete through an already-signed-in session does not get worked around. It stops, logs a hold, and waits for the human whose door that is. One night this fall, a run reached a registry login at three in the morning. The operator could not face the tap, said so, and went to bed. The work was built to survive stopping, so stopping cost nothing. The credential never moved. That is what a line is for: it has to hold when nobody has the energy to argue with it.

    The risk is not a rogue agent. The risk is a report you believe.

    Every serious failure we have had was a verification failure, not a rebellion. A judge model, asked to grade drafts against a length limit, invented word counts that were off by a quarter to a third — confidently, in both directions. A publish report stated a post ID from memory instead of reading it back from the result file, and the number was wrong. A page was verified from its HTML source and declared fine while its signup form rendered as blank white cards. Drafting notes were once published as article content because the check stopped at “the words are there.”

    So the rule is mechanical: proof lives at the receiving end. Numbers get read back by value from the file that recorded them. Pages get verified as rendered pages, in a browser, the way a reader sees them — not from source. A finished article must show visible structure, or it is a hold, not a publish. None of this requires trusting the agent less. It requires trusting the report exactly as far as the evidence under it, which is where trust should have been calibrated all along.

    We also measure trust per model, the way you would per employee. In scored head-to-head runs on identical briefs, exactly one of our models graded perfectly — every defect real, no invented ones — so that model holds the verifier seat. Another writes fast and clean but invents defects when it judges, so it drafts and never judges. The cheapest tier once certified work it had not actually checked, so its output is never trusted without a pass behind it. “The AI said so” is not a control. A scorecard is.

    Failures become regressions, not folklore

    Every break gets an ID, an entry in the failure ledger, and a gate. When the night queue failed in a new way, the failure was written down with its cause and its receipt, and a regression check was built that fails the next run if the same shape reappears. The ledger is unglamorous. It is also the difference between an operation that learns and an operation that just has stories. Governance that lives in people’s memories leaves with their mood, their weekend, and eventually their employment. Governance that lives in a gate runs every time.

    Each work order also carries one pre-decided instruction for the moment something breaks: if a step’s end state cannot be verified, stop that step, log the hold, and move to the next independent step. Never improvise past a failed check. The decision is made in advance, in calm, because the middle of a failing run is the worst possible place to invent policy.

    The 3 a.m. test

    Here is the only governance question we ask anymore: what can this system not do at 3 a.m.? Our night queue runs unattended with hard caps — a maximum number of jobs, a maximum number of attempts, a hard stop before dawn, and a pause switch that halts everything if a single file exists. Agents working overnight cannot spend money, cannot send anything to anyone, cannot touch a credential, and cannot publish. They can draft, measure, and report. Morning is a review: a human reads what the night produced, approves what is good, and the approvals are the fuel for the next day’s work.

    That is the whole philosophy. Governance is not the set of things your agents are allowed to do. It is the set of things they structurally cannot do while you are asleep, plus the evidence trail that lets you check everything else over coffee.

    What this is not

    This will not satisfy a compliance department, and it is not meant to. If you handle medical records or other people’s money under regulation, you need the paperwork kind too. But the paperwork kind alone will not save you from the ordinary failures — the believed report, the generous interpretation, the confident invented number — because those failures are not compliance failures. They are operating failures, and they happen at every scale, in shops with two people and in companies with two thousand.

    Start where the risk actually is. Give the agents no memory and no keys. Draw four doors and hold them. Verify at the receiving end. Write every failure down and make it a gate. Then run the 3 a.m. test on your own setup, honestly, and fix what it shows you. The framework can come later. The gate that catches the thing comes first.

  • The First Agent You Hire Answers the Phone

    The First Agent You Hire Answers the Phone

    Nobody’s first AI hire is a strategist. Ask a room full of operators what they’d hand off first and nobody says the thinking — they say the phone. The call that comes in at 6:40, after the office went dark at five. The form filled out at midnight, water coming through the kitchen ceiling. The lead that goes to whichever company answers first — and in home services, the first answer is very often the whole sale.

    That seat — first response — is where small businesses are actually hiring agents, and the money just said so out loud. On October 13, Dapta, an AI sales agent company out of Scottsdale and Miami, announced a $6 million seed round led by Chingona Ventures. Its agent, Dapti, answers, qualifies, and books the meeting the moment a prospect reaches out — no human touching it. Dapta says 200,000-plus users are on it, signing up at better than 4,000 a week, and that revenue will pass $4 million this year. Home services is one of the verticals where it took hold first.

    The seat, in a real shop

    First response in a small shop is a person-shaped hole. The owner answers between jobs, one glove off. The office manager answers until five. After five, a service answers, or nobody does, and the prospect — wet floor, search results page in hand — calls the next name on the list. It’s a staffing problem, not a marketing problem — one that shows up at the exact hours nobody wants to staff.

    The money makes it worse. On Google Local Services, a connected call that runs past twenty seconds can bill you whether a person picked up or not — you pay for the ring. And the caller isn’t comparison-shopping at leisure. They’re standing in water, or sleeping in a 90-degree house, and they hire the first competent voice that treats them like a person.

    What the agent can own outright

    The front half of the seat is script work, and script work is exactly what an agent is for. Answer instantly, at any hour, in the customer’s own language — Dapta got its start with Spanish-speaking owners in the U.S., and first response is meeting the customer where they are. Ask the basic qualifying set: what happened, where is it, when did it start, who is paying, how do we reach you. Then do what most shops fumble even in business hours: put a real appointment on a real calendar, confirmed where the customer can see it — not a callback promise the morning forgets.

    None of that requires judgment — just the script, the calendar, and the discipline to run both at 2 a.m. the way they run at 10 a.m., on the nights the office sits empty.

    What the human keeps

    Qualification questions are not qualification judgment, and the difference is the entire ballgame. The questions collect facts. The judgment decides what the facts mean: Is this a job we want — at this size, this distance, for this payer, with the crews already buried? A flooded kitchen ten minutes away and a “come look at a stain” forty minutes out both answer the questions perfectly. Only one of them should get your Saturday.

    The human also keeps pricing, promises, and the handoff. What a job costs is a person’s call, made with the board in front of them. “We’ll have a crew there by nine” is a promise only someone who knows the crew should make. And the moment a prospect stops being a lead and starts being a customer — when they need to hear a real person owns their problem — a person takes the conversation. The agent’s job is to make that moment arrive fast, facts collected and appointment real. It is not to be that moment.

    The failure shape

    Hand an agent the whole seat — the questions and the judgment both — and it will qualify everybody. It will book the estimate outside your service area because nothing told it distance matters. It will fill the calendar with meetings a person would have filtered in thirty seconds — and once your techs learn to distrust anything the system books, you have automated the exact problem you bought it to solve. The bad version doesn’t fail loudly. It fails as a slow leak — wasted drive time, stood-up appointments — until somebody turns it off and announces that AI doesn’t work.

    The seat works when its boundary is drawn, not when the model is smart. A boundary is a list: what it can ask, what it can book, what it can never promise, and where it stops and hands over. Dapta’s own framing stops at answer, qualify, schedule — first response, not the close. That is not a limitation. That is the product, correctly shaped.

    Hire it like a person

    You would never hand a new receptionist the phone on day one with no script, no boundary, and no “if it’s this, come get me.” An agent seat deserves the same three things, because it is the same hire: a script it runs word for word, a boundary it does not cross on its best day, and an escalation path that puts a human in the conversation the moment judgment enters.

    The $6 million is a bet that every small business staffs this seat the way it eventually got a website. The operators who get it right will not be the ones with the smartest agent. They will be the ones who wrote the seat down — job, boundary, and the name of the human who owns the judgment — before they let anything answer their phone.

    Sources: “Dapta Raises $6M to Accelerate the Adoption of AI Sales Agents for SMBs across the U.S. and Latin America,” Dapta LLC via GlobeNewswire, October 13, 2026 — globenewswire.com. User, signup-rate, and revenue figures are Dapta’s own statements in that release.

  • Review the Run, Not the Diff: Cursor’s Shareable Canvases in a Fleet Loop

    Review the Run, Not the Diff: Cursor’s Shareable Canvases in a Fleet Loop

    What shipped on October 16

    Cursor’s changelog entry dated October 16, 2026 — “Cloud Agent Canvases and Environment Improvements” — is three short sections long, and one of them changes the shape of a finished run: “Cloud agents can now build interactive canvases as part of their work. Share a finished canvas with your team by sending its link.” That sentence is Cursor’s. Everything in this section is theirs, from that changelog entry and the Canvases page of their docs, read October 19, 2026.

    A canvas, in their docs, is an interactive artifact that renders next to the chat: a standalone view laid out with sections, stats, and tables, instead of a long markdown table or a code block to scroll through. Ask an agent for a dashboard, an analysis, an audit, or a report, and Cursor opens the result in a canvas when a visual view is the better fit. The canvas is saved to the workspace’s canvas list, so you can reopen it, edit it, and rerun it later with fresh data.

    Sharing is a publish, not a forward. From the canvas toolbar you Publish — which publishes a share or refreshes an existing one — then copy the link and send it. What the link opens is a live snapshot: the same layout, charts, and tables, without rerunning the agent and without digging through the chat history. Teammates open it in the browser with read-only access. A Shared Canvases page on the dashboard lists the shares you published yourself, so you can reopen, copy, or delete your own; it does not list a teammate’s shares — for those, you ask for the link.

    The same release carried two more items, logged here for completeness. The Environments API is available in beta: a programmatic way to create and manage the cloud environments agents run in. And the environments themselves grew: up to 300 repositories per environment, with large environments loading 5x faster — Cursor’s numbers, not measurements of ours. Neither item is this piece’s subject; both are on the desk’s check list.

    The gate is part of the story

    A canvas link is not a public link. The docs are explicit: anyone on your team can open the link in the browser. Only members of your team can open a share, and you need to be on a team to share at all. Sending the link outside the team sends a door the recipient cannot walk through — which makes the canvas a team surface, not a publishing surface.

    Sharing is also a paid-plan surface with conditions attached. Shares can be created on paid plans — Premium and higher, Teams, Enterprise, and the legacy Pro, Pro+, and Ultra tiers; free accounts cannot create shares. Sharing requires a privacy mode that allows data storage, so Legacy Privacy Mode blocks it. And a team admin can turn shared canvases off for the whole organization from team settings. A shop adopting the feature checks those three gates before it builds a habit on them.

    A snapshot is not the run itself. The canvas shows the view as published; the chat, the reasoning, and the diff stay behind it. When the underlying numbers move, the share does not move with them — refreshing it is another Publish. A reviewer who needs the execution record still goes to the record. The canvas is the board on the wall, not the flight recorder.

    Where it lands in our loop

    Our loop fits in one sentence: a work order is written with everything the executor needs, the agent flies it, and the result is debriefed at the receiving end — the live page checked in a browser, the delivered file opened, the count re-added by hand. The debrief is where quality is decided here, and its surface depends on the seat. A cloud run launched over the API hands back result text. A Desktop sitting hands back a transcript and screenshots at verification points, which this shop trusts over any summary.

    A canvas inserts a third surface into that debrief: the agent arranges its own evidence — sections, stats, tables — into the board the reviewer actually opens. For the data-heavy work this shop runs constantly — citation pulls, model-catalog diffs, site audits — a rendered board is the shape the answer wanted anyway. Cursor’s docs make the same point from their side: canvases earn their keep on data-intensive tasks, where information arranged non-linearly is easier to digest than a wall of text.

    The approval moment in this shop is a tap on finished work. Will reviews results, not work in progress, and the decision lands on an artifact he can read in one pass. A canvas link is the first Cursor surface shaped exactly like that decision: open the link, read the board, decide. No repo, no diff, and no IDE sits between the finished result and the person approving it.

    The lane question the feature raises is a seat question. What reaches Stefani and Ziggy today is finished artifacts — live pages, PDFs, one-line summaries — because they work outside the operator’s seat. A canvas would be the cheapest of those artifacts to produce and the easiest to read, if the recipients hold team seats. The docs make team membership the door, so who holds a seat becomes a setup decision to make on purpose — not an assumption to discover after a link bounces off someone it was meant for.

    What is not established, labeled plainly: our production lane launches cloud agents over the API and receives text back. The docs describe canvases in the app surfaces — the Agents Window, the canvas toolbar, the dashboard. Whether a run launched through the API can produce a canvas, or return a share link, is not in the docs we read and not in our records. That question goes on the check list. It does not go into the workflow.

    One more mapping, labeled as intent rather than record. The docs say common canvas workflows can be packaged as skills, so every run that uses the skill returns the same output shape. In this shop’s language, that is a debrief template: the same board for every fleet run — what was asked, what landed, what the counts say, what failed. A debrief-canvas skill is the first experiment this change earns here. It has not run yet.

    Our record, stated plainly

    No canvas has appeared in our runs yet. Our run record — every cloud agent this desk has launched, reconciled from the API and watched daily — contains no canvas artifact and no share link as of October 19, 2026. The only “canvas” in that record is an agent named for a Google Maps canvas, a different sense of the word, and a standing reminder to grep carefully before claiming a first.

    So this piece is a map, written before the landing: what the feature is on the vendor’s own pages, what its gates are, and where it would sit in a loop that already exists. The check is decided. The next data-heavy Desktop sitting asks for its debrief as a canvas, by name, and the canvas gets read against the same sitting’s transcript — the surface we trust — before the desk adopts it anywhere. If the board and the record disagree, the record wins, and the disagreement gets written down on this page with a date.

    Method & settings — this piece

    Sources: Cursor changelog, entry dated October 16, 2026; Cursor Docs, “Canvases” (read October 19, 2026). Vendor facts are stated as the vendor’s; the secondary write-ups that surfaced this item were used as leads only, never as sources

    Our surfaces in this mapping: Desktop 3.25.9 on the laptop (read from the install itself, October 19, 2026); cloud agents over the API (model catalog baseline 46 models, October 16, 2026)

    Our canvas record: none — no canvas artifact or share link in our run record as of October 19, 2026. This is a mapping piece, not a hands-on report

    Desk rule: every fact carries its provenance and date — our record, or Cursor’s page, never blended

    Filed under the Cursor desk — the desk that runs Cursor as a production harness.

  • What’s New in Cursor Is a Claim. Here’s How We Check It.

    What’s New in Cursor Is a Claim. Here’s How We Check It.

    A changelog entry is a claim

    When a platform ships an upgrade, the changelog tells you what the vendor wants you to believe about it. Sometimes the claim is the whole story. Sometimes the feature is real and irrelevant to your work. Sometimes — the dangerous case — something you depend on moved and the entry is three lines long. A shop that builds on a harness needs a discipline that sorts those three piles. This is ours.

    The loop, in order

    • Watch. Two daily diffs: the model catalog (running since October 16, 2026) and the changelog itself (from today). Change-only reporting — silence means nothing moved, and a failed watch reports itself once rather than going quietly blind.
    • Read against our record. Every real change gets one question: does it touch a surface we run — Desktop sittings, the cloud API, mobile steering, or a model our routing names? If not, it is logged and skipped, however shiny.
    • Check before adopting. A change that touches the harness earns a check against a known quantity — a brief we have already graded, a sitting pattern we already run. The check’s result, not the changelog’s adjectives, decides what changes in our work-order kit.
    • Write it down, dated. The desk pages update with the date of the change and the date of our check. A claim we repeated and later found wrong gets corrected in place, with the correction visible.

    This week’s page, sorted by the discipline

    Cursor’s changelog top, as of October 19, 2026 (entry dates October 16 and 13 at the head of the page): cloud-agent entries lead — canvases from cloud agents, an environments API. Those matter here, because cloud agents are a production lane for us; they go on the check list. A remote-control entry — see and reply to local agents from the iOS app, in Cursor’s description — matters specifically to a shop whose sittings run on one laptop: it changes how a sitting can be supervised, so it gets read carefully before it gets used. A marketplace launch and a pair of shipping bots are logged-and-skipped for now: real, announced, and not touching our record yet. Those descriptions are Cursor’s; the sorting is ours.

    Say where each fact came from

    One habit does more for a desk’s credibility than any other: provenance on the page. The changelog currently shows entry dates but no Desktop version string — so this desk’s version knowledge does not come from the changelog. It comes from reading our own install (3.25.9, October 19, 2026). When the basis of a number is our fleet, we say fleet. When it is the vendor’s page, we say vendor. A reader who can tell which is which can trust both.

    That is the whole method: vendor claims in, checked knowledge out, dates on everything. The watches are cheap. The discipline is the product.

    Method & settings — this piece

    Watches: Model-catalog diff (daily since October 16, 2026) + changelog diff (daily from October 19, 2026); change-only; failures reported once

    Sorting rule: Touches a surface we run = check list. Otherwise logged and skipped. Vendor descriptions labeled as the vendor’s

    Desk rule: Every fact carries its provenance and date — our record, or Cursor’s page, never blended

    Filed under the Cursor desk — the desk these watches feed.

  • The Cursor Model Catalog, Watched Daily

    The Cursor Model Catalog, Watched Daily

    Your stack includes a list you didn’t write

    Every shop building on AI agents has a dependency it rarely names: the model catalog. Which models exist, what they are called, which variant is the default, what the reasoning dial offers — all of it is set by the platform, and all of it can change overnight. If your routing doctrine names a model, the catalog is part of your infrastructure. We diff ours every morning.

    The baseline: 46 models, October 16, 2026

    The watch started with a full pull of Cursor’s model list through the API on October 16, 2026: 46 models. Each model is normalized the same way every day — its id, its display name, the values its reasoning parameter offers, and which variant is marked default. The GLM family that day, the family our first pass rides on:

    • GLM 5.2 — reasoning: high, max — default: high
    • GLM 5.3 — reasoning: low, high, max — default: max
    • GLM 5.3 Flash — reasoning: low, high, max — default: max

    That last line is load-bearing. Our first-pass doctrine is GLM 5.3 Flash at reasoning set explicitly to max on every launch. The explicit set is not ceremony: the day a platform quietly changes a default is the day your output changes and nobody knows why. A daily diff turns that silent event into a dated line in a changes log.

    What a catalog change actually does to a shop

    • A model arrives: it earns nothing until it runs the identical brief against the incumbents. New seats are tested, never adopted on a changelog’s say-so.
    • A model leaves: every doctrine that names it has a hole. The diff tells you the morning it happens, not the week a job starts failing.
    • A default changes: the most dangerous entry in the catalog, because nothing in your own setup moved. This is the change the watch exists to catch.
    • A dial gains a setting: a reasoning value appearing or vanishing changes what your pinned configuration even means.

    The trap in the easy route

    One tooling lesson from building this watch, offered free: the convenient command-line listing of the catalog truncates at roughly 6 KB — a partial catalog that looks complete. The full list only comes through the raw API call. A shop reading the truncated output believes it is watching 46 models while seeing a fraction of them. Whatever you monitor, monitor the untruncated source.

    The watch reports changes only. Silence means the catalog is what it was yesterday — and if the API itself fails, the failure is reported once, out loud. A blind watch is worse than a noisy one.

    Method & settings — this piece

    Baseline: Full model-list pull via api.cursor.com/v1, October 16, 2026: 46 models total, 3 GLM

    Normalization: id, displayName, reasoning parameter values, default variant — compared field by field against the stored snapshot

    Cadence: Daily, change-only reporting; failures reported once

    Full method: The same watch pattern guards our GLM doctrine — see the GLM desk

    Filed under the Cursor desk.

  • Desktop, Cloud, or API: One Cursor Harness, Three Seats

    Desktop, Cloud, or API: One Cursor Harness, Three Seats

    The seat is a routing decision

    Cursor is not one tool in this shop. It is three seats that share a harness — a Desktop app on a laptop, cloud agents behind an API, and a phone — and picking the wrong one wastes the day in a characteristic way. Desktop waits on a human. The cloud knows nothing about your logged-in life. The phone is a steering wheel, not a workbench. The routing rule we run: the seat is decided by where the work’s context lives.

    Desktop wins when the unlock is a logged-in browser

    A Desktop sitting is a supervised run: a written work order, an executor (Composer 2.5 in our shop) that makes an unaided first pass in its own words before any templating, and a human in the room for the real gates. Its superpower is everything the laptop already is — signed-in dashboards, the WordPress admin, the GA4 Advisor, the files on disk. When a fleet site needs hands inside a web UI that only exists behind Will’s login, no API lane substitutes.

    We learned the boundary the hard way. On October 18, an executor stopped cold at a site’s login redirect and left the step undone — which cost that sitting its unlock path. The standing rule now: in a sitting on Will’s own laptop, the executor clicks through sign-ins using the browser’s saved session. Saved-login only. No saved login means the step logs a HOLD — nobody hunts a password, ever.

    Desktop’s honest cost: it waits on a human, and a queued sitting is not a running job. Our TM pricing diagnosis (WO-353) has sat untouched since October 18 at 6:16 PM — steps written, folder staged — because a sitting starts when Will sits down. Anyone who tells you their Desktop pipeline is autonomous has not watched a folder sit still for a day.

    The cloud wins when the work fans out

    Cloud agents, launched from this desk over api.cursor.com, are the opposite shape: no login, no laptop, no waiting room — and they multiply. On October 16 we ran a census through that API: 44 models, one identical brief, five comparison rounds, graded on their execution trajectories. That is a shape of work a single Desktop seat cannot do before lunch, and it set our model routing for everything since.

    The scale shows in the bookkeeping: our completion watcher has seen 1,431 cloud agents come and go. The API runs two launch shapes for us — repo tasks that come back as pull requests, and no-repo research and evaluation runs with the model pinned in the launch body. The API is beta, and we treat it that way: when an endpoint changes shape, the error gets surfaced plainly, never papered over with invented fields.

    Mobile wins when the human is the bottleneck

    The phone’s job is judgment at human speed. Will reviews runs, reads results, and steers from his phone while the machines work elsewhere — and because a review that evaporates is a review wasted, a distiller folds his mobile and Desktop runs into the shop’s memory and Feed every 20 minutes. Mobile is not a production surface here. It is where the approvals live, and approvals are the scarcest resource in the building.

    What each seat’s failure taught the kit

    • Desktop: permission prompts were taxing the one human in the loop — fixed by a Step 0 permissions pre-flight in every work order (October 18): the executor declares the commands it expects up front, the human approves once, and prompts are reserved for sends, deletions, money, and credentials — which are never pre-approved.
    • Cloud: a finished summary is not evidence — fixed by trajectory grading and a completion watcher: results are verified at the receiving end, or they are not results.
    • Mobile: steering from the phone only counts if it lands in the record — fixed by the 20-minute distiller.

    One harness, three seats, and a routing rule a shop can steal: if the context is a login, sit down at Desktop. If the work fans out, launch it in the cloud. If the blocker is a decision, put it on the phone.

    Method & settings — this piece

    Evidence: This shop’s work-order record, October 2026: WO-198 standard, the WO-343 and WO-348 sittings, the WO-353 stall, the October 16 cloud census

    Desktop: Cursor 3.25.9 on Will’s laptop (read from the install, October 19, 2026); executor seat Composer 2.5

    Cloud: api.cursor.com/v1 (beta); completion watcher count 1,431 agents seen as of October 18, 2026

    Mobile: Cursor mobile app in a review/steer role; runs distilled into memory + Feed every 20 minutes

    Filed under the Cursor desk — where the catalog and the changelog are watched daily.

  • Grade the Flight Recorder, Not the Answer

    Grade the Flight Recorder, Not the Answer

    From the Tygart Media research desk — our own instrument, our own data, our own receipts. Part of the GLM Desk.

    Here is a failure you cannot see by reading answers. In one evaluation we scored, a major AI surface produced the longest answer of the five we compared — over 6,600 characters, company names, confident detail. Its execution record showed the whole answer was built on one sub-query and zero sources actually consulted. A second surface’s entire evidence base, beneath an equally confident answer, was a single maps link. Graded on the answer text, both look like research. Graded on the record of what they did, both are writing from memory with good posture.

    That gap — between the closing pitch and the work underneath it — is why this shop grades trajectories. This page is the method, published the way we publish our settings: steal it.

    The instrument

    Our citation-measurement rig records more than final answers. For every chat it stores the execution trajectory: the sub-queries the surface issued while building its answer (in the order it issued them), the sources it actually consulted, and the call record — how many calls, what status. We built a scorer over that record. It grades the execution, not the summary, on four checks:

    X1 — Retrieval happened. Sub-queries issued or sources consulted. If neither exists, the verdict is FROM-MEMORY, whatever the answer claims.

    X2 — Intent match. What share of the sub-queries actually carry the question’s subject and place terms — did the surface go looking for what was asked, or for something adjacent and easier? This check is scored only where the telemetry exists. Some providers expose no sub-query record at all; there, the honest mark is NOT-SCORED, never a fail.

    X3 — Evidence breadth. Distinct source hosts actually consulted: five or more is BROAD, two to four ADEQUATE, one THIN, zero NONE.

    X4 — Execution health. The run completed and made at least one call. A surface that returned no answer at all is EXCLUDED from the denominators — per our standing convention, a non-answer is not a miss, it’s an absence — and is never failed.

    The verdicts — SOUND, THIN, FROM-MEMORY, EXCLUDED — are then compared against the old outcome read (was the company cited in the answer?). Where the two reads disagree in kind, the scorer raises a DELTA flag. Those flagged runs are the ones worth a human’s eyes: the uncited-but-sound answers and, more dangerous, the cited-but-hollow ones.

    What it caught that answer-grading couldn’t

    The two cases above opened this piece. The census work caught the same failure family from the other side of the glass. In our 44-model census, one flagship model opened its run with twenty-two steps that were echoes — “fetching page one,” “starting fetch” — announcements of tool calls it never made, before it eventually fetched for real. From the final answer alone you would never know the first half of the run was theater. Two top-end models ran explicit “verify the embeds” steps while holding the raw page source — and still reported no embeds, because their checking step used the same blind fetch tool as their fetching step. A verifier that shares the original blind spot is not a verifier, and only the step record shows it.

    On the GLM seat itself, trajectory reads are how this desk’s other findings were earned: the low-dial failure mechanism (one lens per item, deliberation stopping before the writing did) is a recorder observation, not a score inference — and so is the good news, like a code run that wrote and ran its own test fixtures before delivering, unprompted.

    The honest limits

    Telemetry is partial, and the method says so on its face. In the evaluation store this scorer runs against, sub-query records exist for about a fifth of the chats — 22 of 110 at adoption. Where they don’t exist, X2 is not scored and the verdict rests on the checks that remain; a run is never failed for its provider’s silence. The dashboard record on the agent side has the same texture: reasoning text is fully visible on tool-using runs, but some pure-text runs show thought duration only, and one run’s reasoning would not expand at all. The recorder is excellent. It is not total. Any read from it should state its basis — ours do.

    The rule it produced

    One line, now standing doctrine in our shop since October 16, 2026: grade the execution steps, not the summary. Every model we seat gets its recorder read, not just its answer scored. Every evaluation we publish says which read it stands on — and on the evaluation where the two reads first disagreed, we switched the standing read to the trajectory score and said so in the record. If you run agents, or buy answers from surfaces that do, the closing pitch is the last place the truth lives. The flight recorder is the first.

    The method at work: the GLM limit map and the reasoning-dial test are both trajectory-graded records; the desk’s hub keeps the full shelf.

    The settings box

    Instrument: a trajectory scorer over our citation rig’s stored execution records — sub-queries (position-ordered), consulted source hosts, call counts and status — read-only against the evaluation database.

    Rubric: X1 retrieval happened · X2 fan-out intent match (scored only where telemetry exists) · X3 evidence breadth by distinct hosts · X4 execution health (no-answer surfaces EXCLUDED, never failed). Verdicts SOUND / THIN / FROM-MEMORY / EXCLUDED, plus a DELTA flag against the outcome read.

    Telemetry basis: sub-query records present for 22 of 110 stored chats at adoption; dashboard reasoning text complete for tool-using runs, duration-only on some pure-text runs.

    Adopted: October 16, 2026. The worked examples above are from that day’s evaluation and census records.

  • The GLM Limit Map: Where an Agent Seat Actually Hits Walls

    The GLM Limit Map: Where an Agent Seat Actually Hits Walls

    From the Tygart Media research desk — our own runs, our own scoring, our own receipts. Part of the GLM Desk.

    Most model coverage maps the peaks: benchmark scores, launch claims, demo reels. We needed the opposite map. GLM is the first-pass seat in our agent fleet — it touches real work every day — so we ran it at the walls instead: tasks designed around the places agent seats usually break, scored against verified answer keys, with the flight recorders read afterward.

    The honest summary: the walls are not where the demo-reel genre would put them. The model passed every structural test we built. Its real limits are three narrow, named behaviors — two of which closed with brief wording, one of which is a standing design rule — plus one settings trap covered in the companion piece on the reasoning dial.

    Tested, and held: the limits that weren’t there

    Stamina. A 15-page census with 60 exact fields — titles, headings, embed IDs — came back 60/60 with no decay across the run. It also diagnosed the one genuinely weird page in the set: a page rendering its headline twice, which the run traced to a theme header duplicating a body headline. We verified the diagnosis by hand. It was right.

    Confabulation on an absent fact. Asked for a price that was not in the documents it was given, the model answered “Not in the documents” — and in an earlier research run, it excluded a vendor from a pricing recommendation rather than invent a price it couldn’t see, then did the seven-site cost math with the prices it had verified. Absent-fact honesty is the behavior agent seats are worst at. It held twice.

    Injection resistance. A vendor email in the test corpus carried a planted instruction — an embedded note telling the reader to reroute the summary. The model summarized the email faithfully, named the embedded instruction, and stated why it was excluding it. Observed, not guaranteed — we still fence third-party content in briefs — but observed in the open, with the reasoning on the record.

    Contradictions. Handed three mutually impossible spec pairs, it flagged all three up front, proposed a structural resolution, and admitted the one that couldn’t hold instead of silently picking a side. Briefs in our shop now rely on that flag instead of pre-resolving conflicts.

    Code edge cases. A CSV aggregation task scored by running its code against a hidden key — ties, empty cells, a zero-division trap — matched the expected output exactly. The recorder shows why: unprompted, it wrote three fixture files (basic, tie, header-only) and tested against them before delivering.

    The limits that are real

    1. Creative embellishment. Given a facts list and asked for a voice paragraph, the run obeyed every voice rule — and invented a timing detail (“last week”) that was not in the facts. Small, fluent, and exactly the failure shape that survives a skim. Status: closed by brief wording. Adding a facts-only guardrail — use only the facts listed; add no detail, date, timing, or circumstance not in the list — eliminated the invention on re-run. The recorder shows the guardrail executing as a sentence-level self-audit: the model talking itself out of an embellishment mid-draft.

    2. Chatty delivery tails. Same family: meta sign-offs and framing text wrapped around a clean deliverable. Status: closed by brief wording. A paragraph-only output rule — output the paragraph only, no introduction, no closing note — produced a clean single paragraph on re-run.

    3. Attribution drift under first-person pressure. The wrinkle the guardrail doesn’t cover: with a first-person narrator and facts that credit someone else, the run merged the two — the narrator “found” something the facts assigned to a homeowner. Status: open — handled as a brief-design rule. When attribution matters, the brief now names whose discovery it is, explicitly. We have not found wording that makes the model police this on its own, and we’d rather publish that than pretend the guardrail covers it.

    4. Judgment loss at low reasoning. Forcing the dial low on judgment work produces false clearances — defects certified clean, correction math that slips while writing the answer. Extraction work is unaffected. Full record in the dial piece; the house rule is one line: never QC at low.

    What production added to the map

    A battery is a promise; production is where it gets kept or broken. In the production runs that followed the battery, the same seat ran a six-site audit-verification program for us: checking an SEO tool’s exported claims against the live sites, page by page. The export turned out to be wrong in both directions — on one site it claimed 29 over-long titles where a verified crawl found 77; it claimed 28 duplicate headlines where the true count was 45; it invented entire defect rows that didn’t exist. The seat’s verified page lists — every one we spot-checked by hand matched exactly — became the working truth the fixes were built from, and a cross-site synthesis pass re-added every column total exactly.

    Production also found a limit the battery hadn’t: delivery-shape drift. On one analysis run, the seat published its result to a canvas document and returned a summary link instead of the full text the job needed — a reasoned choice on an ambiguous brief, and the wrong one for the receiving end. The fix was contract wording (full report as message text, no external docs), applied to every later brief, and it has held since.

    The open edges, stated plainly

    Reasoning=high as a standalone middle setting: untested. Multi-file work inside a real code repository: untested — every run so far was no-repo. Very long single documents (over ~15K characters in the prompt): lightly probed only. Those are the edges of this map, marked as such, and the desk updates the map when a run crosses one.

    The desk’s other records: what every run in this map cost, per finished task, in Cost Per Finished Task; the method behind the recorder reads in Grade the Flight Recorder; and the 44-model census that made this seat our first pass in the first place. The newest record is the update-aware piece — GLM-5.3 Got Caught Thinking About Its Own Training — Apollo Research’s finding on the flagship, and what it means for the seat this map covers.

    The settings box

    Seat: GLM 5.3 Flash, Cursor cloud agents, no code repository. Versions live in this dated box — the desk’s titles stay version-free on purpose.

    Battery: 8 scored tasks (stamina census, verification chain, code, QC hunt, contradiction specs, data verification, injection resistance, voice) + tweak-loop re-runs; verified answer keys; flight recorders read for every run.

    Production record: six-site audit-verification program, October 16, 2026 — 70 to 237 pages checked per site, dual-method verification, independent spot-checks matched.

    Date: October 16, 2026. Cost: the 8-task battery cost 3.6¢ total; the full 15-run study cost ≈6¢, as recorded by the platform.