AI Operations - Tygart Media

Category: AI Operations

  • Your Coding Agents Live on One Machine. T3 Code Puts Them in Your Pocket.

    Your Coding Agents Live on One Machine. T3 Code Puts Them in Your Pocket.

    Your coding agent is running on your desktop. You are not at your desktop. That gap — between the machine where the work happens and the person who has to approve the next step — is the whole problem T3 Code exists to close.

    T3 Code is an open-source “agent harness control surface” from the T3 Tools team (the repo is pingdotgg/t3code on GitHub, MIT licensed). It is not a model. It is not a new coding agent. (If you are still choosing between the agents themselves, start with our Claude Code vs Cursor comparison – this piece is about what sits on top of whichever one you picked.) It is a small server that runs on the machine where your agents already live, and it remote-controls the ones you already pay for: Claude Code, Codex, Cursor, Grok Build, OpenCode, Google Antigravity, and fx. A phone app, a web app, a desktop app, and a terminal command all drive the same threads.

    The demand is not subtle. The repository passed 50,000 stars this week — 50,470 when we read it on the morning of November 7, 2026, up more than 16,000 in the week to November 6, the largest weekly gain of any AI project on GitHub. It was created in February 2026. Nine months from zero to fifty thousand stars is what a widely felt gap looks like when somebody finally fills it.

    What it actually does

    Install the t3 command on the host machine, connect at least one provider using that provider’s own login (claude auth login, codex login, agent login for Cursor — Antigravity needs no CLI; you enable it in Settings and sign in with Google), and start the server. It listens on your machine, port 3773 by default. Register a project, start a thread, and the agent works in that project exactly as it would if you were sitting there.

    From that point you have four ways to reach the same work:

    • The phone app (iOS and Android, free) — start runs, watch threads, approve a step or send a correction, browse files, review diffs, run version-control actions, use the terminal. The Android listing describes it as “pretty much the full power of the desktop app.”
    • The web app — the same surface in a browser.
    • The desktop app — Electron, on Windows, macOS, and Linux.
    • The t3 CLI itself — t3 thread start, t3 thread send, t3 thread list from any terminal. A thread waiting on you exits with its own signal, so scripts can tell “finished” apart from “blocked on the human.”

    Two connection routes matter. On your own network — or over a private network like Tailscale — you pair a device directly with a one-time link or QR code, no account at all. Away from home, T3 Connect is the managed relay: no router configuration, sign in on the host, sign in on the phone, pick your machine. Per the hands-on guide we worked from, a free T3 Connect account links up to 3 machines.

    Every thread writes to its own branch. When the work is good, one button opens the pull request on GitHub with a generated title, body, and changelog — after you’ve reviewed the diff inline. The agent does the typing. You keep the merge.

    What it costs

    Nothing for the software. T3 Code is free and MIT licensed — “If you don’t like something, fork it” is a headline feature on its own site, with the fork command printed under it. It does not resell tokens and it does not hold your credentials hostage: you bring your existing subscriptions, log in with each provider’s own flow, and model usage is billed by your provider exactly as before. “Bring your own sub. No keys resold. No quota caps.”

    That pricing shape is the point. The control layer is becoming a commodity; the subscriptions underneath it are the spend. A control plane you can fork can never raise its rent on you.

    The honest limits

    The README says it in plain words: “We are very very early in this project. Expect bugs.” Believe it. The stable release this week is v0.1.7. This is a fast-moving, nine-month-old project, not settled infrastructure, and the team is mostly not accepting contributions yet.

    Three operational limits follow from the design:

    1. The host has to stay awake. Your agents run on your machine, not in T3 Code’s cloud. On Linux and macOS you can install the server as a background service (t3 service install). Windows gets no background service — you leave the desktop app running, and closing its last window stops the local server.
    2. Remote access is a security decision, not a default. On a local network, the pairing code is the only thing between your agents and every other device on that network. Pair per device with fresh one-time links, don’t enable LAN access on a network you don’t trust, and prefer a private network like Tailscale for anything beyond the couch.
    3. It controls agents; it doesn’t supervise them. T3 Code moves the approval to your phone. It does not decide whether the work order was well-specified, whether the agent’s output is right, or whether the diff should merge. That judgment problem is the same one behind our MCP tool-poisoning checklist: the harness around the agent is where the safety lives. The judgment layer is still yours.

    How this maps onto a multi-seat shop

    We run several agent seats — Claude, Cursor, Antigravity, Grok — and the standing problem with seats is presence. Work stalls at approval points because the human isn’t at the keyboard the agent is attached to. Anyone who has watched a finished piece of work sit idle for hours because it was waiting on a tap that could have happened from a phone knows this stall by name.

    Against that setup, T3 Code is a fit in three specific places:

    • It covers the seats we actually run. Claude Code, Cursor, Antigravity, and Grok Build are all on its provider list today. One surface over all of them beats four vendor apps with four different ideas about remote access.
    • It keeps the work on our hardware. The alternative shape — cloud agents that keep running while your machine sleeps — means your code and data live on the vendor’s machines by design. T3 Code’s answer is the opposite trade: your machine stays the plant, and the phone is just the window into it.
    • It matches how the work is already shaped. Bounded task per thread, worktree or branch isolation for unreviewed work, diff review before merge — that’s the same discipline as a work order with receipts. The remote control doesn’t change the discipline; it removes the geography from it.

    Where it doesn’t fit is just as clear. It doesn’t replace the harness — the work orders, the context, the QC on what comes back. A remote control for a badly briefed agent just lets the agent be badly briefed from further away. And for work that genuinely has to run while every machine you own is off, a self-hosted control surface is the wrong tool no matter how good the app is.

    The verdict

    Real, and early. The star count is the loudest signal, but the quieter one is the shape: open source, multi-provider, your hardware, your subscriptions, forkable if the team ever takes it somewhere you don’t want to go. That is the correct shape for a control layer, and it’s the shape the closed vendor apps don’t offer.

    Try it the cheap way: one machine, one provider you already pay for, one bounded thread started at your desk and approved from your phone. If that loop feels like the missing piece, it earns a place. If it doesn’t, you’ve spent ten minutes and nothing else — which, for a tool at version 0.1.7, is exactly the right size of bet.

    Sources: the T3 Code repository and README (github.com/pingdotgg/t3code — 50,470 stars, 9,813 forks, MIT license, repo created February 8, 2026; read November 7, 2026); t3.codes (positioning, provider list, fork-it terms; read November 7, 2026); AI Frontier Post hands-on tutorial, “T3 Code: drive Claude Code, Codex and Cursor from your phone” (install, pairing, service, and T3 Connect machine-limit details, verified end-to-end by its author against v0.1.7; published November 7, 2026).

  • The Carrier Moved Into ChatGPT: MGT’s Aimee, Mapped Against the Wisdom Trust

    The Carrier Moved Into ChatGPT: MGT’s Aimee, Mapped Against the Wisdom Trust

    On November 5, 2026, MGT Insurance — a full-stack commercial carrier — listed its AI quoting assistant, Aimee, in the ChatGPT app directories and opened its MCP, so appointed brokers can quote a business policy by typing a sentence. This is a mapping: the new model read against the Wisdom Trust — our open kit for capturing elders’ life stories, and its paid human sibling, the Wisdom Manager. Two earlier mappings in this series read NHS Life Stories (October 18, 2026) and LifeBio’s Engagement Services (October 24, 2026) the same way. Where MGT’s public pages are silent, this says so rather than guessing.

    The two things, in one paragraph each

    MGT / Aimee. MGT is a full-stack, licensed commercial P&C carrier — an “AI-native neo-insurer” (A- rated by AM Best, per its release) that owns its product, its platform, and its risk, selling small-business cover (today: Business Owner’s Policy, 300+ business classes across 43 states and D.C.) through independent agents. Aimee is its broker-facing AI agent: since 2025 she has answered appetite questions on mgtinsurance.com with no sign-in; on October 16, 2026 MGT became, by its own claim, the first carrier to offer chat-based quoting — an agent describes a business in plain language (or uploads an ACORD application) inside ChatGPT or Claude and gets a real rate; on November 5, 2026 the integration was listed in the ChatGPT app directories, with MGT “opening up our MCP so brokers can quote where they already work.” Aimee classifies the business, checks MGT’s appetite, asks only for what is missing, prices the quote, and — the load-bearing detail — “tells the agent what she assumed and why.” Every quote then opens in MGT’s own portal, where the human agent reviews it and binds. MGT’s platform numbers ($83B of quoted TIV, nearly 15,000 appointed agents) are the company’s own, printed in its release; trade coverage notes MGT has not disclosed how many agents use the ChatGPT channel, what time it saves per quote, or what volume has bound through it.

    Wisdom Trust (Will). Two related things. The kit: an open-source starter set (MIT, explicitly “a seed, not a product”) for capturing retirement-facility residents’ life stories — one emailed question per week, answered by voice through a single link with no account, curated by an AI pipeline into a family-owned collection, framed as inheritance (“a life documented like a 401k left behind”). The storyteller owns the material outright; the machine’s outputs are drafts for human approval; nothing outward is ever auto-sent. The Wisdom Manager: a sketch for a paid human service — part curator, part oral historian, part creative director — that turns a family’s scattered media into a living collection through a gated process (private intake → curator review → owner approval → presentation), priced from ~$1,000 guided products to $20,000+ commissions. Both halves are built to be run by the people they serve; neither is published as a tool inside a platform somebody else owns.

    Side by side

    Dimension MGT / Aimee Wisdom Trust (kit + Wisdom Manager)
    Capture prompts / structure Appetite-first. Before any full submission, Aimee gives a real-time read on whether a class/state fits MGT’s appetite (the published Appetite Guide covers 300+ classes with NAICS groupings). In a quote she classifies the business, checks appetite, then asks only for what’s missing — the structure is the carrier’s underwriting rules, proprietary, applied conversationally. The prompt surface is whatever the agent types: a sentence, pasted call notes, an uploaded ACORD. A fixed library of 40 written questions across a life, one sent per week, skippable at will; the pipeline’s final stage (“Notice Gaps”) reads the collection and generates the next questions from what’s missing. The “asks only for what’s missing” discipline exists in his design too — but at stage 8 of the pipeline, after collection, not at the front door before it.
    Media types Plain-language text and documents: typed descriptions, pasted call notes, uploaded ACORD applications and supporting files, which Aimee “turns into a quote, flagging any values worth confirming.” Voice-first. A spoken (or typed) answer in a chat, 20+ languages, transcribed verbatim then cleaned; the pipeline can render artifacts back out — image, music, video, voice — each labeled with what it is, what it is not, and why it was made. The Wisdom Manager side curates media a family already has.
    Who does the capturing The machine, employed by the carrier. Aimee does the data entry, classification, appetite check, and pricing; a second agent (Athena, per MGT’s own essay) has made end-to-end underwriting decisions “with no human input.” The human in the loop is the broker — a professional intermediary — who reviews the finished quote in the portal and binds. The insured business is described, not consulted. The elder answers alone, by link; a family archivist or staff champion sends the question; staff are guides, not interviewers. The machine curates, but every outward artifact is a draft for owner approval — nothing auto-sends, ever. Both models keep a human gate before the consequential act; the gatekeepers differ (a licensed broker binding cover vs. the owner of the material approving its use), and so does whom the machine works for.
    Entry / onboarding Two doors, deliberately tiered. The appetite door is open to anyone — “you can still chat with Aimee about appetite, with no sign-in required.” The quoting door requires an MGT appointment (a broker contract) and signing in with MGT credentials inside ChatGPT/Claude; appointment itself is a sales process (mgtinsurance.com/get-appointed). Once appointed, the friction claim is real: “They don’t need another form or another login” — the quote starts inside the assistant the agent already uses. One link, no app, no account, no password — a stated non-negotiable: “If the storyteller has to install anything, the design failed.” Consent is signed before the pilot starts; there is no tiered front door — no way to feel the thing, saving nothing, before the consent conversation. The friction didn’t move to procurement as with LifeBio; there is no procurement. But there is also no anonymous first touch.
    Who the finished work serves, and where Three beneficiaries: the broker (time back — the scarcest resource in MGT’s own framing), the small business (a bound policy it never had to fill in a form for), and MGT (distribution into the rooms where brokers already work, plus appetite-consistent risk selection). The finished work lives in MGT’s portal — the quote opens there, is reviewed there, binds there. The ChatGPT surface is the front step; custody of the record stays with the carrier. Serves the family and descendants: an heirloom — stories, timeline, quote cards, people/places index, a weekly family letter, a gallery page. The facility’s benefit is real but secondary and reputational. The finished work lives wherever the family keeps its collection — the kit’s whole custody posture is that the platform is a shelf, not an owner. The Wisdom Manager serves the paying family directly, owner-approved before anything is shown.
    Consent / custody / ownership The public documents are website-era documents, and the ownership check shows it (quotes below). The privacy policy (last updated Oct 21, 2026 — two weeks before the ChatGPT listing) never names Aimee, ChatGPT, Claude, or MCP, states no retention period, and contains no mention of training (verified by full-text search of the published page: zero hits for “Aimee,” “train,” “retain”). It reserves broad improvement purposes over submitted information: personal data may be used for “Auditing, research, and analysis in order to maintain, protect, and improve our services,” “Developing new services,” “To model our risks,” and “To make our products and services better”; “We may combine the information submitted under various forms and services… to improve the quality of our services.” It does state “We do not sell Personal Information.” The website terms contain no license grant over user-submitted content at all — nothing equivalent to LifeBio’s AI-training licence, in either direction — and on termination say only that MGT may terminate the account “at any time and for any reason”; what happens to a broker’s submitted data or quote history on termination is not addressed. No designee or succession concept exists in either public document. The operative broker terms (appointment agreement, portal terms, MCP-channel terms) sit behind the appointment process and are not public. One more custody layer is new with this launch: a submission made inside ChatGPT also passes through OpenAI’s platform, under OpenAI’s terms — the chain now has two companies in it before the carrier’s own documents even apply. The most heavily specified layer of the kit. A plain-language consent: the elder owns their stories, period; access only by the elder’s grant (family included — not by default); grant and revoke at will; delete permanently and immediately; never sold; voice never used to train products without separate written permission; a designated person decides after death, defaulting to deletion after 12 months if none is named. “The facility’s role is shelf, not owner.” The Wisdom Manager carries the same posture into the paid service: safety gates (private intake → curator review → owner approval → presentation) are “part of the product.”
    Output format A priced, reviewable quote — a real rate, not an estimate — carrying an assumption statement (“what she assumed and why”), which opens in the MGT portal for review and binding into a policy. The assumption statement is part of the output object, not a disclaimer under it. A structured collection, not a single object: raw + cleaned transcripts, story records, timeline, quote cards, people/places index, weekly digest letter (draft), gallery page (draft), and labeled generated artifacts — all in JSON buckets any future AI can re-render. Artifacts carry provenance labels (what it is, what it is not, why it was made); nothing in the kit attaches an assumptions record — what the machine inferred where the storyteller didn’t say — to any output.
    Institutional / commercial model A regulated company selling risk: a licensed, full-stack carrier that monetises bound premium. The AI channel itself carries no published price — it rides on the broker appointment (contract terms not public; no figures published for the channel). Appetite spans 300+ classes in 43 states + D.C. (Florida and Hawaii excluded; five states listed as coming soon). The MCP is opened free, as distribution: the quoting engine is the marketing. Note what trade coverage could not find either: no disclosed user counts, time-saved, or bound volume for the new channel — the launch is measured in platform totals, not channel outcomes. Deliberately not an institution and not a company: an MIT-licensed seed its author declines to operate (“I’m not going to be the gardener on this one”). The commercial sibling, the Wisdom Manager, is priced as independent practice — role-hour maths, ~$1,000 guided products to $20,000+ commissions, family pays. Neither side of his model publishes anything into someone else’s platform or charges by distribution; there is no channel, only a kit people pick up.

    The door moves: an open MCP, and the product stops being a destination

    NHS Life Stories is a place you go and build. LifeBio is a person who comes to you. MGT’s Aimee is neither: the product dissolves into whatever assistant the broker already has open. By listing in the ChatGPT directories and opening its MCP, MGT stopped asking brokers to visit a destination and instead published its quoting engine as a callable tool — any MCP-capable assistant (ChatGPT, Claude, and next, the broker’s own in-house agents) can invoke the carrier mid-conversation. That is a distribution mechanism neither earlier mapping has, and it inverts the kit’s founding move in an instructive way: his one-link flow deletes the destination for the storyteller (no app, no account — the capture comes to the elder). MGT deletes the destination for the professional — the capture comes to where the broker already works, and the broker’s own AI can be the one calling. What it buys:

    • Distribution without a destination. The directory listing is the shelf space. A carrier that can be quoted “by typing a sentence” competes inside every conversation a broker has, not inside a portal tab the broker must remember to open.
    • Agent-to-agent quoting becomes possible. Once the engine is a tool, the caller doesn’t have to be a human typing — a broker’s own agent, working a renewal list overnight, can call Aimee the same way. MGT says this plainly: the engine “was designed from day one to be called by agents, human and AI.”
    • The assumption statement is the trust patch that makes it viable. Moving quoting into a chat window removes the form’s forced precision; Aimee’s answer is to ship her assumptions with the quote and ask instead of guessing when something is missing. Speed is the pitch; stated assumptions are what let a professional rely on it.

    And what it costs, in terms his files would price honestly:

    • The surface is no longer theirs. Inside ChatGPT, MGT’s product renders under OpenAI’s chrome, beside competitors one directory row away, under a second company’s terms. The carrier traded a destination it controls for reach it rents.
    • The custody chain lengthens exactly where the documents are thinnest. A broker’s submission now passes a platform company’s terms before it reaches a carrier whose own public privacy policy never mentions the channel exists (see the ownership row). The mechanism is new; the paperwork is a website policy last updated before the listing.
    • “Open” is doing quiet work. No public developer documentation, endpoint, or tool specification for the MCP appears on the pages read — the openness is a listing, granted to appointed agents through two named platforms, not a published interface anyone can build on. It is an open door into a closed house: the engine, the appetite, and the submission data stay proprietary.

    What the Wisdom Trust could borrow

    1. An assumption ledger on every machine-made artifact. Aimee ships “what she assumed and why” with every quote. His artifacts carry provenance labels (what it is, what it is not, why it was made) but no record of what the machine inferred — which date it guessed for an undated story, which “Uncle Ray” it merged with which. Adding an assumptions array to the schemas (each entry: the inference, the evidence, a confirm/correct affordance for the owner) turns stage 4’s silent enrichment into something the family can audit — and it is the same fact-gating instinct his fleet work already runs on, applied to the kit.
    2. A two-tier front door: a no-save taste before the consent conversation. MGT’s appetite chat is open to anyone with no sign-in; only quoting requires the contract. The kit has one door, and it’s paperwork. A public “answer one question, nothing is kept” demo — one joy prompt, answered by voice, wiped when the tab closes — would let a family feel the thing before anyone signs anything, and would give facilities a tour artefact stronger than the one-pager. The consent template stays exactly as strict; the door in front of it gets lighter.
    3. Appetite before paperwork, as a designed step. Aimee checks fit before collecting anything and asks only for what’s missing. His pilot’s first act is consent; a two-minute fit conversation (does she want to talk about her life? joy-first or wisdom-first? who should hold the collection?) before the forms would put the kit’s existing gap-noticing discipline at the front of the flow instead of only at stage 8.
    4. Publish the kit’s functions as a callable tool, not only a link. The kit’s automation README is already a plug-in contract an AI can execute — the seed of an MCP-shaped door. MGT’s move shows the distribution value of finishing that thought: a family archivist’s own assistant could invoke “this week’s question” and “file this answer” as tools, meeting the archivist inside the assistant they already use, exactly as Aimee meets the broker inside theirs. The one-link flow stays for the elder; the archivist gets a second door.

    What his does differently, on purpose

    1. Ownership is answered in advance, in plain language — here the contrast is silence plus reservation. Against LifeBio, his template differed from stated terms (a training licence, discard on termination). Against MGT, the public terms state almost nothing about submitted content — no training licence is taken, which is genuinely better — but broad improvement and risk-modelling purposes are reserved over whatever is submitted, the channel itself is never mentioned in the privacy policy, and the documents that would settle the quoting channel’s ownership questions are contract-side and unpublished. His template answers every one of those questions before the first recording: whose it is, who may hear it, what happens when the relationship ends, who decides after death.
    2. Whom the machine works for. Aimee’s appetite is MGT’s appetite; she quotes one carrier’s product and her assumptions serve the carrier’s risk selection as much as the broker’s convenience. His pipeline works for the elder and family — its drafts wait for the owner’s approval, and its gap-finding serves the collection, not a seller. Both keep a human gate before the consequential act; the difference is whose human, and whose interest the machine was built to advance when the two diverge.
    3. Openness of the artifact vs. openness of the interface. His kit is open all the way down — MIT, forkable, schemas published. MGT’s openness stops at the interface: the MCP is listed and callable (by appointed agents, on named platforms), while the engine, the appetite logic, and everything submitted stay inside. Neither is a pose; they are opposite answers to “what do you give away to get distribution?” — he gives away the machine and keeps no channel; MGT keeps the machine and gives away the doorway.

    What he would likely reject, per his own files

    • Reserved improvement/modelling use of submissions as a standing term. His consent template promises: never sold, never used to train products without separate written permission, access only by the elder’s grant. MGT’s privacy policy reserves using submitted information to “improve our services,” “develop new products and services,” and “model our risks,” with an opt-out mechanism that applies to new purposes via a contact page. Risk modelling is ordinary, legitimate insurance practice — and it is still exactly the shape of clause his template exists to refuse: purposes named by the holder, changeable by the holder, consent handled as opt-out.
    • Changeable-at-will terms. The website terms “may be changed, modified, supplemented, or updated at any time, with or without advance notice,” with continued use counting as acceptance. His consent is a signed, plain-language document the elder can revoke at will; the terms of the relationship are not a web page one side edits.
    • A persona users mistake for a person. His pipeline labels every generated artifact with what it is and what it is NOT. MGT’s own essay reports, approvingly enough to print, that Aimee’s “users thank her and ask her to start their quotes, most of them not realizing she’s an AI” (the essay’s title is “They Don’t Know It’s an AI Bot”; MGT, to its credit, says it would rather answer the question in public than dodge it). Per his labeling rule, an assistant a user can’t tell is a machine is a disclosure defect, not a delight metric.
    • Credentials inside a third party’s surface as the consequential door. Quoting requires signing in with MGT credentials inside ChatGPT/Claude — the broker’s carrier login now lives in a platform the carrier doesn’t control. His non-negotiable deletes accounts and passwords for the person at the centre of the capture. (Nuance, noted in the table: the appetite door is credential-free — the tiering itself is borrowable #2.)

    Gaps in his own files (marked, not filled)

    • No machine-callable surface. His files describe a kit humans run and a pipeline an AI runs on the back end — but nothing about publishing the kit’s functions as tools other assistants can call, being listed anywhere, or distribution through a platform’s directory. MGT’s whole launch is that surface. The automation README is the seed of it; the discovery/distribution question is unasked in his files.
    • No assumption ledger. His stages enrich silently: dates inferred, people merged, gaps noticed — but no output carries what the machine assumed and why, in a form the owner can confirm or correct. Aimee’s quote does. (Borrowable #1 names the fix; this entry marks the silence.)
    • No eligibility step before collection. His pilot opens with consent paperwork and a 10-resident scope; nothing first asks fit — does this resident want this, which track, joy-first or wisdom-first — the way appetite precedes a quote. The appetite conversation is two minutes and saves the paperwork for people it fits.
    • The dementia silence, third mapping running (carried from NHS Life Stories, repeated in the LifeBio mapping, still open). Aimee exposes nothing here — commercial quoting is not its territory — but the standing instruction of this series is that a repeated silence gets named as repeated: his question library still assumes a storyteller who can sit with an abstraction, and no mapping since has closed it.
    • Custodian succession. His consent template settles what happens when the elder dies (a designated person decides). It does not settle what happens if the shelf changes hands — the facility is sold, the keeper of the vault exits. MGT’s privacy policy at least names the asset-sale transfer case for its side; his files leave the equivalent case unaddressed.

    Could not verify from public pages (MGT side)

    • The operative broker terms. The appointment agreement, the portal terms, and any terms specific to the MCP/directory channel sit behind the appointment process and are not public. The ownership questions for the quoting channel itself — who owns a submitted ACORD and the data extracted from it, whether it trains models, what happens to submission history when an appointment ends — are therefore unverified: the documents exist but are contract-side, not published. The public website terms and privacy policy were read in full and are silent on each.
    • What the “open MCP” technically is. No public developer documentation, endpoint, tool list, or authentication spec for the MCP was found on the pages read. “Open” is established as a distribution claim (listed in the directories, callable from ChatGPT and Claude), not as published developer access.
    • The second platform’s terms. Data submitted through the ChatGPT (or Claude) surface also passes under OpenAI’s (or Anthropic’s) terms for directory apps. Those terms were not read for this mapping, so the full custody chain of a broker’s submission is unverified at the platform layer.
    • The headline numbers. $83B quoted TIV, “nearly 15,000 appointed agents,” the “A-” AM Best rating, and “first carrier” are MGT’s own claims from its release and site. Trade coverage (GlobalFinTechEdge) narrows “first” to a carrier-specific quoting integration and records that MGT has not disclosed active ChatGPT-channel users, average time saved per quote, or policies bound through the channel.
    • Quote performance. No independent source on how often Aimee’s quotes bind as priced, how her classifications hold up, or how assumption statements read in the live ChatGPT surface (no transcript was available; the one concrete premium — $2,740/yr for a Sacramento bakery BOP — comes from MGT’s own demo video).
    • Athena’s end-to-end underwriting. The claim that an AI underwriting agent decided a case with no human input, “and got it right,” is from MGT’s own essay; no external account exists on the pages read.
    • Whether Aimee identifies herself as an AI in the quoting surfaces. MGT’s essay title and text (“users thank her… most of them not realizing she’s an AI”) describe the website agent; the disclosure behaviour of the ChatGPT/Claude listing itself was not observable from public pages.

    Sources

    • The occasion — Insurance Edge republication of the release (Nov 6, 2026): https://insurance-edge.net/2026/11/06/us-news-mgts-aimee-ai-assistant-now-listed-in-chatgpt-directories/
    • Original release (Business Wire, Nov 5, 2026): https://www.businesswire.com/news/home/20261105657905/en/MGT-Becomes-First-Insurance-Carrier-to-Bring-ChatGPT-Quoting-to-Independent-Agents
    • MGT — first carrier to offer chat-based quoting (three ways to quote; portal review before bind): https://www.mgtinsurance.com/blog/first-carrier-chat-based-quoting-independent-agents
    • MGT — how AI underwriting cuts quote time (Aimee in ChatGPT/Claude/portal; appetite with no sign-in): https://www.mgtinsurance.com/blog/how-ai-underwriting-cuts-quote-time-for-independent-agents
    • MGT — BOP appetite page (300+ classes; states covered/excluded): https://www.mgtinsurance.com/appetite
    • MGT — “The Neo-Insurer Bet” essay (Athena; “They Don’t Know It’s an AI Bot”; the disclosure question): https://www.mgtinsurance.com/blog/the-neo-insurer-bet
    • Trade coverage noting the undisclosed channel metrics and the narrow reading of “first” (GlobalFinTechEdge, Nov 2026): https://globalfintechedge.com/news/mgt-brings-ai-insurance-quoting-assistant-to-chatgpt/
    • InsureWire distribution tracker (Oct 16, 2026 announcement entry): https://insurewire.org/digital-insurer/agents-distribution/
    • Privacy policy (last updated Oct 21, 2026 — read in full; findings quoted above): https://www.mgtinsurance.com/privacy-policy
    • Website terms & conditions (read in full): https://www.mgtinsurance.com/terms-conditions
    • The Wisdom Trust kit and the Wisdom Manager service sketch — Tygart Media working papers; the two earlier mappings in this series are dated October 18 and October 24, 2026.
  • You Learn to Cook When You Have No Money

    You Learn to Cook When You Have No Money

    Stop blaming the token limit

    Every time an AI tool tightens a rate limit, the same crowd shows up to complain about it. The bot got slower. The bot cut me off. The bot won’t let me do what I was doing.

    Here’s a question nobody asks them: what were you doing?

    Because most of the time, the answer is nothing. Testing it. Poking it. Making it write a poem about your cat, summarize a video you were never going to watch, argue with it for forty minutes to see if it breaks. That’s not work. That’s burning reps on stupid shit and then complaining the gym is too small.

    Token limits aren’t the problem. Usage discipline is. And the people crying the loudest about limits are usually the people who never had any.

    Treat it like a gym, or don’t go

    An AI model is either a gym or an expensive tool, depending on how you treat it. It is not a toy.

    You don’t blame the gym because you did curls for three hours and your arms hurt. You show up with a plan. You do the work that’s actually on the program. You rack the weights and you go home. A table saw works the same way — it doesn’t care about your feelings, it rewards the person who measured twice and punishes the one who was playing around near the blade.

    AI is the same. Every session should start with a reason. Every call should buy something: a decision, a draft, a number you can check. If you can’t say what a run bought you, you weren’t working out. You were hanging out at the gym.

    Scarcity is the teacher

    You learn to cook when you have no money.

    When the pantry is almost empty, every ingredient has a job. You stop wasting cuts. You learn what heat actually does. Rich kitchens produce lazy cooks; empty ones produce good ones — if the cook cares enough to learn.

    Tokens are ingredients. When they feel unlimited, people cook like it: giant prompts with no point, five agents doing what one careful prompt would do, whole afternoons spent “exploring.” When every call costs you something — money, quota, time on a clock — your prompts get honest in a hurry.

    I know what mine buy. Last week I shipped a working agent system into a national hackathon on a $153 budget and spent $102.50 of it, every single call logged. This morning a research run I use cost under two cents and came back with a ranked answer I could act on. That’s not being cheap. That’s knowing the price of everything I asked for. Discipline isn’t deprivation — it’s receipts.

    A nearly empty pantry and a cook making a real meal from almost nothing

    The commute is the session

    Here’s how I’d actually run it, and it’s the whole philosophy in one picture.

    Buy a Tesla. Install the bot. Grok lives in the car — and only in the car.

    I live in Puyallup. The day job, the in-office days, are up in Bellevue. That’s a real drive, and a self-driving car turns it into the best office I’ll ever have: nobody interrupts a commute. The drive in is the Jarvis session. Run the side businesses. Clear the decisions that piled up overnight. Plan the day out loud while the car does the driving. If Tony Stark had ever given Pepper a suit, this is what she’d have done with the flight time — run the company from inside it.

    The drive home is the debrief. What got done, what’s open, what’s tomorrow. Then the car parks, and the session is over.

    You don’t sit in your car in the driveway and watch the football game. You go in your house.

    That’s the part people miss. The commute works as a session because it ends. Forty-five minutes of total focus with a wall around it beats nine hours of AI open in a tab while you half-watch your life go by. Sparingly isn’t a restriction. Sparingly is the design.

    A car parked in a driveway at dusk while the driver walks toward a warm-lit house

    Stop testing it like a macro

    And stop testing AI like it’s just a macro. This shit is more than that.

    A macro does the same thing every time and tells you nothing. Poking a model with toy questions tells you what it does in a toy situation, and then people act surprised when production behaves differently. You learn a tool by putting weight on it — real work, real stakes, a customer on the other end of the output. Every real thing I’ve learned about these systems, I learned from a run that mattered, under a limit that forced me to mean it.

    So no, the rate limit isn’t stealing your productivity. It’s offering you a program. Most people just don’t want to train.

    The limit is the workout

    Here’s the whole thing in one line: the limit isn’t the wall. The limit is the workout.

    The people who learn to cook with nothing in the pantry end up eating better than the people with a full fridge and no discipline — because skill compounds and quota doesn’t. Give the disciplined operator a bigger limit later and it’s terrifying. Give the complainer a bigger limit today and he’ll just run out faster, louder.

    Buy the car. Install the bot. Use the drive. Then go in the house.

    More from the operator desk: Slack Is the Last Mile — the hopper, and why the last step of every system is a person. And if you want the receipts live: I’m teaching the citation system behind all of this in a free session series, November 9–17 — the AEO sessions hub has the schedule and the question form.

  • Slack Is the Last Mile

    Slack Is the Last Mile

    Will Tygart | Tygart Media | November 3, 2026

    I was supposed to be in Seattle today. I stayed at my desk instead — and realized I was already standing in the thing I was going there to learn about.

    Download this article as a PDF — free, no email, no strings.

    Writing about this? Take the free Field Kit (PDF) — the argument, the facts, and what it means industry by industry. Built to feed your bot.

    I had a plan for today. Salesforce was bringing World Tour Essentials to Seattle — Tuesday, November 3, 1:30 to 5:00 p.m. at the Sheraton Grand Seattle — and Slack was a big part of why I wanted to be in the room. Not for the keynotes. For help. I needed help understanding something I could feel but could not quite name about how work moves now, and I figured the people who built Slack could name it for me.

    Then I sat down, looked at the work in front of me, and stayed here.

    Not because the trip stopped mattering. Because somewhere between deciding to go and deciding to work, the understanding I was going to Seattle to get showed up on its own. I was already stepping in it. I had been stepping in it for a couple of years, in different ways, without ever calling it by its right name.

    This is the name: Slack is a hopper. Slack is the last mile. And I owe them a tip of the hat for building it that well.

    I was going to Seattle to get help understanding this

    That is an honest place to start, because it is the truth of how most operators learn anything that matters. You do not learn it from a diagram. You live inside a problem long enough that the shape of the solution starts to press on you, and then you go looking for somebody who can confirm the shape.

    My problem, for a long time, has been intake. Everything arrives at once. Messages, files, links, requests, half-finished ideas, client problems, things somebody found on the internet at midnight and thought I should see. If you run a small operation in 2026, you do not have a shortage of material. You have a flood of it, and the flood does not sort itself.

    What you need is a place where it all lands first. One place. Wide at the top, forgiving about what gets thrown in, and built so that nothing important falls on the floor while you figure out what it is. In the trades we would call that a hopper. You dump the load in the hopper, and then — and only then — does it flow down to the work.

    I kept building versions of that idea in my own systems without noticing that I had spent years working inside a very good one that somebody else had already built, refined, and put in front of millions of people.

    The last mile is not where work travels. It is where work arrives — and becomes a decision a human can actually make.

    What “last mile” means here

    Delivery people use “last mile” for the hardest part of the route: not the highway, not the warehouse, but the final stretch to the door. That stretch is where packages get lost, where addresses turn out to be wrong, where a human being has to be home and paying attention.

    Work has the same problem. A tool can move data across the internet in milliseconds. Getting that data to land in front of the right person, in the right context, with enough of the conversation around it that the person can judge it — that is the hard stretch. Slack solved that stretch, and they solved it so completely that most of us stopped seeing it as a solved problem at all. We just call it “where work happens,” because that is what it feels like from the inside.

    Slack built a hopper with people standing inside it

    Here is the part I had not fully appreciated until today, and it is the whole article in one sentence: a dumb hopper just collects. Slack collects and gives people a place to stand inside the collection while it is still arriving.

    Material lands — a message, a file, an alert from another app, a thread that starts as a joke and turns into a decision. Before any of it flows downstream into a ticket, a document, a task, or a build, people can do the most human work there is with it: look at it together, argue about what it is, ask what is missing, decide who owns it, and decide whether it deserves to flow at all.

    That middle station — triage and discussion, inside the intake, before the routing — is what separates a hopper from a pile. A pile is where material goes to be forgotten. A hopper with people standing in it is where material goes to be understood.

    • Everything can land. Channels take the messy, early, unformatted version of a thing, which is the only version most real work ever starts as.
    • Context travels with it. The thread keeps the argument attached to the artifact, so a decision made downstream still carries its reasons.
    • People decide before machines execute. The flow downstream is a choice, not an accident of arrival order.

    Once you see Slack that way, a lot of its design choices stop looking like chat features and start looking like intake engineering. Threads are sorting. Huddles are a quick triage call without leaving the hopper. Canvases and lists are what happens when triaged material needs a more durable shape before it moves on. Search is the ability to reach back into the hopper and prove what actually arrived, and when, and who touched it.

    That is not a messaging app that got popular. That is infrastructure.

    They say it themselves — in plainer language than mine

    I want to be careful here, because a tip of the hat should not put words in anybody’s mouth. So let me use theirs.

    Salesforce now describes Slack as “The Agentic Work Operating System” — a platform for building, automating, and coordinating work across your whole tech stack, in the one place where conversation leads to action. Their platform materials talk about connecting people, data, and agents in a single workspace, with more than 2,700 agents and apps available in the Slack Marketplace by their count, and Slack included with new Salesforce orgs.

    And when Slackbot — the assistant built into Slack — was relaunched as an enterprise agent, Parker Harris, Slack’s CTO and a Salesforce co-founder, said it in the sentence I wish I had written:

    “Slackbot isn’t just another copilot or AI assistant. It’s the front door to the Agentic Enterprise.”

    Front door. Last mile. Hopper. These are three ways of saying the same true thing from three different chairs. The front door is where everything enters. The last mile is the final stretch it has to survive to reach a person. The hopper is the vessel that holds it while people decide what it is. Salesforce is naming the doorway. I am naming the room behind it.

    What matters is that they clearly know what they built. This is not a company stumbling into relevance in the agent era. Their own roadmap reads like a deliberate answer to the question every operation is now asking: if agents are going to do more of the work, where do humans and agents meet, look at the same material, and agree on what happens next? Their answer is: in Slack, in conversation, where the work already lives.

    My read: You cannot claim the metaphor for yourself when the builder already printed it on the box. What you can do is confirm it from the floor — as an operator who has run real work through it — and say plainly that the claim holds up.

    The plumbing is real, and it runs both directions

    A hopper only earns its keep if things can flow out of it as reliably as they flow in. This is where Slack’s last couple of years get genuinely impressive, and where my own understanding finally caught up today.

    The connective tissue is MCP — the Model Context Protocol, the open standard that gives AI agents a consistent, secure way to use outside tools and data. Slack now works both sides of that protocol, and the two directions matter for different reasons.

    Inbound: agents can reach the hopper

    Slack hosts an official MCP server. Approved AI clients outside Slack can search conversations, read channel history, and post updates through a standardized interface, under workspace permissions that admins control. In plain terms: the material in the hopper is no longer trapped in the hopper. An agent working elsewhere can come and get the context it needs, with receipts, instead of a human copying and pasting it across.

    Outbound: the hopper can reach everything else

    Slackbot, in turn, now works as an MCP client. From inside a conversation, it can call out to connected apps and their MCP servers — documents, tickets, CRM records, design files, calendars — figure out which tool fits the request, and bring the result back into the thread. Salesforce has paired that client with its own MCP servers for CRM, analytics, and data, so a person can ask in plain language and watch work that used to mean six tabs happen in one conversation.

    Put the two together and the architecture is complete: everything your stack produces can land in one conversational place, people can stand there and triage it together, and both humans and agents can route it onward without the place itself becoming a bottleneck or a silo. Add Slack’s Real-Time Search API, its workflows and intake templates, and the long-standing app ecosystem underneath, and you do not have a chat tool with integrations. You have an operating layer with a conversation on top of it.

    I do not say that lightly. I build intake and routing systems for a living right now. I know what the hard parts are. They did the hard parts.

    What two years of working in it teaches you

    I could not have written this article two years ago, and I could not have written it from a conference seat today either. That is not modesty. It is the actual lesson.

    I have worked with Slack in different ways across the last couple of years — as a place where a small team coordinated, as a surface other tools reported into, as a room where material arrived faster than anybody could gracefully handle it. Some of those uses were good. Some were chaotic. All of them taught me something a keynote cannot: you learn what a hopper is by watching what happens to the load when nobody is tending it, and what happens on the good days when somebody is.

    On the good days, Slack is the calmest place in an operation. The material is visible. The argument about the material is visible. The decision, when it comes, is visible — and because all three live in the same place, nobody downstream has to guess why a thing was done. That is worth more than any single feature. Most operational pain is not a shortage of tools. It is a shortage of shared, inspectable context at the moment of decision. Slack manufactures that context as a byproduct of people simply working there.

    The honest footnote

    Here is the part a sponsored post would leave out, and the part that makes this a tip of the hat instead of an advertisement: I stepped away from Slack for my own day-to-day operations this fall. The desktop app came off my laptop. Work that used to route through our Slack workspace started routing elsewhere.

    That was not Slack failing. I want that on the record, because it is the most credible thing I can say in their favor. The hopper did not break. What happened is simpler and more human: there was nobody left standing in ours. A hopper is a social machine as much as a technical one. If the people who triage do not live in the room anymore, the room goes quiet no matter how well it is built — and an operator follows the people, not the platform.

    If anything, leaving taught me the value more sharply than staying would have. You find out what a place was doing for you when the material starts landing somewhere with no one standing in it.

    What nobody in that room does yet

    A tip of the hat does not have to pretend the work is finished. So here is the one honest coda, offered the way an operator offers it to a builder whose work he respects: there is a station missing inside the hopper, and as far as I can tell, nobody has built it yet — not in Slack, and not anywhere else I have looked.

    Every triage system I have seen, on Slack and off it, sorts material the same three ways. Is it real, or is it noise? Who owns it? How urgent is it? Those are good questions. They move work.

    But none of them asks the fourth question: is what is in this material actually true?

    A message can be real, owned, and urgent — and still be wrong. A summary can be fluent and false. A number can arrive with total confidence and no source behind it. In an era when more and more of what lands in the hopper was written or assembled by machines, sorting by urgency without checking for truth is how fluent errors get routed downstream at machine speed, with a human’s name on the approval.

    I do not raise that as a criticism of Slack. Slack built the room, the doorway, and the plumbing. Verification is a different discipline from intake, and it may well belong to the people and agents standing in the room rather than to the room itself. In my own work, that is exactly where I have ended up putting it: material waits, gets checked against its sources, and only flows when a person gives it the tap. The packet does not assemble itself just because it arrived.

    But I will say this: whoever builds that station well will build it in a place shaped like Slack, because that is where the material and the people already meet. The room comes first. The checking happens inside it. In that sense, even the next idea I am chasing is downstream of what they built.

    They built the last mile. The next mile starts inside it.

    A tip of the hat, plainly

    So I did not make it to Seattle today. The Sheraton Grand will host plenty of people who needed to be there more than I did, and Salesforce will run a good show — expert sessions, live demos, hands-on learning, all of it free, by their listing. I hope somebody in that room has the moment I had at my desk, only faster: the recognition that the thing they came to understand is a thing they have already been living inside.

    I stayed and worked instead. And the work itself kept handing me the evidence. Every time material arrived and needed a place to land where a person could see it, judge it, discuss it, and route it — the shape in my head was the shape Slack spent years building and refining. I could not have done the work I have done, the way I have done it, without having worked with Slack across the last couple of years in different ways. It taught me the pattern by letting me live in it.

    That is what a tip of the hat is for. Not a purchase. Not an endorsement deal. Just an operator, in print, saying to a builder: you did the last mile really well, you have been doing it well for a while, and some of us who build in your shadow know exactly how hard that stretch is — because we have watched lesser versions of it fail, and we have watched yours hold.

    Slack is the last mile. They built the front door, the hopper, and the room where people stand inside it and decide together. Everything else in the modern stack flows because that room exists.

    Tip of the hat. Now back to work.

    — Will Tygart
    Tygart Media, Puyallup, Washington

    Sources

    Illustration is an original artwork created for this article. Product names belong to their owners. This article is an independent operator’s account, not a Salesforce or Slack publication.

  • Every SOP Needs a Name on It

    

    The first time your company runs into a job it has never seen before, don’t send your fastest technician. Send your most experienced one.

    The most experienced tech doesn’t just see the job in front of him. He sees it the way the company sees it. He notices how this job touches the next five jobs, where the traps are, and what goes wrong if it’s done the cheap way. That kind of seeing can’t be written down by somebody who wasn’t there.

    He comes back with two things: a finished job, and the standard for every version of that job that follows. The finished job pays once. The standard pays every time the phone rings after that.

    After that first run, the job doesn’t belong to the technician anymore. It belongs to the procedure. The next tech doesn’t need the first tech’s twenty years of judgment. He needs the SOP and the discipline to follow it to the T. The judgment was already spent — by the right person, at the right time, on purpose.

    When the field hits something the procedure doesn’t cover, it goes back to the person who wrote it. Not sideways into improvisation. Back. The scope changes when the curator agrees it changes, and not before. Otherwise fifty jobs turn into fifty slightly different ways of doing the job, and nobody can tell you which one is yours anymore.

    Here is where most companies lose it. Their procedures belong to the company, which means they belong to nobody. A binder of SOPs with no name on any of them is a museum — well-organized, carefully written, and dead. Nobody checks whether reality has drifted away from the page, because noticing was never anybody’s job.

    Every SOP deserves an owner. A leader. A champion. Its soul, if we’re being honest about what actually keeps a standard alive. Put their name on it. Their responsibility is to uphold it, improve it, digest what the field learns, share it, and teach it like it matters — because to them, it does.

    Passion does not travel through paper. A new hire does not catch your standard from reading a document. He catches it standing next to the person whose name is on the document, watching how much that person cares whether it’s done right. The owner’s pride is the real enforcement system. No audit ever caught what a champion’s raised eyebrow catches.

    Companies say they have a documentation problem. They don’t. They have an ownership problem. A procedure with an owner gets better every time it runs. A procedure without one starts dying the day it’s printed.

    Put a name on it.