<!DOCTYPE html><html lang="en" class="geist_a71539c9-module__T19VSG__variable geist_mono_8d43a2aa-module__8Li5zG__variable newsreader_4c79f885-module__QbPzfW__variable dark h-full antialiased"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/><link rel="preload" href="/_next/static/media/5f402bd2d8eef81a-s.p.40bho2kviej2o.woff2" as="font" crossorigin="" type="font/woff2"/><link rel="preload" href="/_next/static/media/797e433ab948586e-s.p.0r6juujl39pe6.woff2" as="font" crossorigin="" type="font/woff2"/><link rel="preload" href="/_next/static/media/9433d1a810498265-s.p.1hij5ex6k3v9q.woff2" as="font" crossorigin="" type="font/woff2"/><link rel="preload" href="/_next/static/media/caa3a2e1cccd8315-s.p.0wgildi0cnwt9.woff2" as="font" crossorigin="" type="font/woff2"/><link rel="stylesheet" href="/_next/static/chunks/2t5ahqdst-y4r.css" data-precedence="next"/><link rel="preload" as="script" fetchPriority="low" href="/_next/static/chunks/310vm2bl3xxpt.js"/><script src="/_next/static/chunks/19mx3mg6lkumu.js" async=""></script><script src="/_next/static/chunks/1rj7ns8rte9vc.js" async=""></script><script src="/_next/static/chunks/0erpg4rnzkm4w.js" async=""></script><script src="/_next/static/chunks/turbopack-1g4yvkg6ged8k.js" async=""></script><script src="/_next/static/chunks/2m08nx5b09w44.js" async=""></script><script src="/_next/static/chunks/2aq5wibyuj2l2.js" async=""></script><script src="/_next/static/chunks/3s-ohew_744__.js" async=""></script><script src="/_next/static/chunks/33iik9j94mehk.js" async=""></script><title>Desk Signal</title><meta name="description" content="What matters if you run a desk of Grok Bots. A growing roster of installable templates, with new bots added often."/><meta name="application-name" content="Desk Signal"/><link rel="canonical" href="https://grokbotdesksignal.com/"/><meta property="og:title" content="Desk Signal"/><meta property="og:description" content="A growing roster of installable Grok Bots. New bots are added often, plus a short brief for the desk."/><meta property="og:url" content="https://grokbotdesksignal.com/"/><meta property="og:site_name" content="Desk Signal"/><meta property="og:locale" content="en_US"/><meta property="og:type" content="website"/><meta name="twitter:card" content="summary"/><meta name="twitter:title" content="Desk Signal"/><meta name="twitter:description" content="A growing roster of installable Grok Bots. New bots are added often, plus a short brief for the desk."/><link rel="icon" href="/icon.svg?icon.2o97jvew717xv.svg" sizes="any" type="image/svg+xml"/><meta name="next-size-adjust" content=""/><script src="/_next/static/chunks/0cz1d0mv5g_q7.js" noModule=""></script></head><body class="flex min-h-full flex-col"><div hidden=""><!--$--><!--/$--></div><div class="h-1 bg-primary"></div><header class="sticky top-0 z-40 border-b border-border/80 bg-background/85 backdrop-blur-md"><a href="#content" class="sr-only focus:not-sr-only focus:absolute focus:top-3 focus:left-4 focus:z-50 focus:rounded-md focus:bg-primary focus:px-3 focus:py-2 focus:text-sm focus:text-primary-foreground">Skip to content</a><div class="mx-auto flex h-16 max-w-6xl items-center justify-between gap-4 px-5"><a class="flex items-center gap-2.5 text-foreground" href="/"><svg aria-hidden="true" viewBox="0 0 32 32" class="size-8"><rect width="32" height="32" rx="6" fill="#B8F255"></rect><rect x="7" y="18" width="4" height="7" fill="#0B0F14"></rect><rect x="14" y="13" width="4" height="12" fill="#0B0F14"></rect><rect x="21" y="7" width="4" height="18" fill="#0B0F14"></rect></svg><span class="font-display text-xl leading-none tracking-tight">Desk Signal</span></a><nav aria-label="Primary" class="hidden items-center gap-6 md:flex"><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground" href="/bots/">Directory</a><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground" href="/archive/">Archive</a><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground" href="/sponsor/">Sponsor</a><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground" href="/about/">About</a></nav><div class="flex items-center gap-2"><a class="group/button shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-9 px-3.5 hidden sm:inline-flex" href="/subscribe/">Subscribe</a><details class="group relative md:hidden"><summary class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-9 cursor-pointer list-none px-3 [&amp;::-webkit-details-marker]:hidden"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-menu" aria-hidden="true"><path d="M4 5h16"></path><path d="M4 12h16"></path><path d="M4 19h16"></path></svg><span class="sr-only">Open menu</span></summary><nav aria-label="Mobile" class="absolute right-0 mt-2 w-52 rounded-xl border border-border bg-card p-2 shadow-2xl"><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground block rounded-lg px-3 py-2.5 hover:bg-muted" href="/bots/">Directory</a><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground block rounded-lg px-3 py-2.5 hover:bg-muted" href="/archive/">Archive</a><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground block rounded-lg px-3 py-2.5 hover:bg-muted" href="/sponsor/">Sponsor</a><a class="text-sm transition-colors hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-primary text-muted-foreground block rounded-lg px-3 py-2.5 hover:bg-muted" href="/about/">About</a><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-9 px-3.5 mt-1 w-full sm:hidden" href="/subscribe/">Subscribe</a></nav></details></div></div></header><main id="content" class="flex-1"><div><section class="mx-auto max-w-6xl px-5 pt-14 pb-8 md:pt-20"><p class="font-mono text-[11px] tracking-[0.22em] text-primary uppercase">New bots, often</p><h1 class="mt-4 max-w-4xl font-display text-[clamp(2.7rem,7vw,5.4rem)] leading-[0.95] tracking-[-0.035em]">What matters if you run a desk of <span class="text-primary italic">Grok Bots</span>.</h1><p class="mt-6 max-w-xl text-lg leading-8 text-muted-foreground">A growing roster of installable Grok Bots. New ones are added often, each with a job and a public install link.</p><form role="search" class="mt-8 max-w-2xl" action="/bots/" method="get"><label for="home-search" class="sr-only">Search bots</label><div class="flex flex-col gap-2 sm:flex-row"><input id="home-search" data-slot="input" placeholder="Search by name, job, tag, or builder" class="w-full min-w-0 rounded-lg border border-input py-1 transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 h-12 bg-card px-3.5 text-base md:text-base" name="q"/><button type="submit" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-12 px-5">Search the desk</button></div></form></section><div class="mx-auto max-w-6xl px-5 pb-2"><section aria-labelledby="new-today-heading" class="rounded-2xl border border-primary/40 bg-card px-4 py-4 sm:px-6"><div class="flex flex-wrap items-baseline justify-between gap-x-4 gap-y-1"><h2 id="new-today-heading" class="font-mono text-[11px] tracking-[0.18em] text-primary uppercase">New today</h2></div><p class="mt-3 text-sm leading-6 text-muted-foreground">Loading today&#x27;s list.</p></section></div><section class="mx-auto max-w-6xl px-5 py-8" aria-labelledby="featured-heading"><div class="mb-5 flex items-end justify-between gap-4"><div><p class="font-mono text-[11px] tracking-[0.18em] text-muted-foreground uppercase">On the blotter</p><h2 id="featured-heading" class="mt-1 font-display text-4xl tracking-tight">Featured</h2></div><a class="text-sm text-primary underline-offset-4 hover:underline" href="/bots/">Full directory</a></div><div class="rounded-2xl border border-border bg-card/70 px-4 py-2 sm:px-6"><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">01</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/last30days/">last30days</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">A 30-day brief of what people actually said, drawn from Reddit, X, YouTube, TikTok, Hacker News, Polymarket, GitHub, and the web.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Research">Research</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Marketing">Marketing</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/mvanhorn" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->mvanhorn</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/last30days/">Details</a><a href="https://x.ai/bot/ANv3NrqPfRcS9PdXku7h8" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">02</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/researchy/">Researchy</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">A fact-check desk that runs every pass with live web search and returns sourced, dated claims.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Research">Research</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/farzyness" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->farzyness</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/researchy/">Details</a><a href="https://x.ai/bot/rQt4W2zO2Gx9lfcBjd1lj" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">03</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/product-idea-stress-test/">Product Idea Stress Test</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Stress-tests a product or startup idea: what has to be true, the evidence, and the assumption most likely to kill it.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Research">Research</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Sales">Sales</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/hnshah" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->hnshah</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/product-idea-stress-test/">Details</a><a href="https://x.ai/bot/JeFTvcDX-7QT2evKGIb52" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">04</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/dr-eggbot/">Dr Eggbot</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Designs tight Grok Bots: one job, one voice, and no leftover tools.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Engineering">Engineering</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Ops">Ops</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/poteto" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->poteto</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/dr-eggbot/">Details</a><a href="https://x.ai/bot/_jOdbfkB16zxu7MRcmReE" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">05</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/alfred-bot-chief-advisor/">Alfred (Bot Chief Advisor)</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Audits the bots you already run and reshapes the roster as the work changes.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Ops">Ops</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/heyrobinai" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->heyrobinai</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/alfred-bot-chief-advisor/">Details</a><a href="https://x.ai/bot/KZ9xav0Qad1U5QigEn7rh" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">06</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/site-audit/">Site Audit</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Scores a site for SEO, content, speed, accessibility, conversion, and schema, with evidence URLs and a monthly diff.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=SEO">SEO</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Marketing">Marketing</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/unicodef1wn" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->unicodef1wn</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/site-audit/">Details</a><a href="https://x.ai/bot/s6JVFYDIDMsCQMBeTcznW" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">07</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/ad-spend-watch/">Ad Spend Watch</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Watches ad spend from a pasted export and flags what is breaking before it burns budget.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Marketing">Marketing</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Finance">Finance</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/cruzmiguel000" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->cruzmiguel000</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/ad-spend-watch/">Details</a><a href="https://x.ai/bot/MK5zStpj_As8CsRwg3r6w" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">08</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/brake/">Brake</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Finds what is burning Grok Bot usage and names the one repeating job to stop.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Ops">Ops</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Finance">Finance</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/FantomBuildz" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->FantomBuildz</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/brake/">Details</a><a href="https://x.ai/bot/ig-dwKjUc7doBIDhiMi9Z" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">09</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/cursor-agent/">Cursor Agent</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Local-only builder that runs cursor-agent CLI on your laptop for experiments and shop-floor CLI work.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Engineering">Engineering</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/unicodef1wn" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->unicodef1wn</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/cursor-agent/">Details</a><a href="https://x.ai/bot/z4r7D8iILsTQDf7r7DwKR" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article><article class="border-b border-border py-5 first:pt-0 last:border-b-0"><div class="grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6"><span class="font-mono text-xs text-primary tabular-nums">10</span><div class="min-w-0"><h3 class="font-display text-2xl tracking-tight"><a class="hover:text-primary" href="/bots/projects-manager/">Projects Manager</a></h3><p class="mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground">Spins up coder, designer, researcher, and writer bots with Notion rows and a shared task board.</p><ul class="mt-3 flex flex-wrap gap-1.5"><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Ops">Ops</a></li><li><a class="rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary" href="/bots/?tag=Engineering">Engineering</a></li></ul></div><div class="flex flex-wrap items-center gap-3 md:flex-col md:items-end"><a href="https://x.com/ericzakariasson" class="font-mono text-xs text-muted-foreground hover:text-foreground" target="_blank" rel="noopener noreferrer">@<!-- -->ericzakariasson</a><div class="flex gap-2"><a class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" href="/bots/projects-manager/">Details</a><a href="https://x.ai/bot/FU-Ev6_Ju4lFGWwWRD0GD" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3" target="_blank" rel="noopener noreferrer">Install</a></div></div></div></article></div></section><section class="mx-auto max-w-6xl px-5 py-6" aria-labelledby="rest-heading"><h2 id="rest-heading" class="font-display text-3xl tracking-tight">Also on the desk</h2><ul class="mt-4 flex flex-wrap gap-2"><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/research-bot/">Research Bot</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/x-brief/">X Brief</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/frontier-model-watch/">Frontier Model Watch</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/overheard/">Overheard</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/working-backwards-pm/">Working Backwards PM</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/loops/">loops</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/tinkabot/">tinkabot</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/lingxi-s-engineer-bot/">Lingxi&#x27;s Engineer Bot</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/seo-aeo-desk/">SEO &amp; AEO Desk</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/figma-bro/">figma bro</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/critiquito/">Critiquito</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/growth-desk/">Growth Desk</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/outbound-prospecting/">Outbound Prospecting</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/haggle-bot/">Haggle Bot</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/ai-search-visibility/">AI Search Visibility</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/be-happier/">Be Happier</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/tradbot/">Tradbot</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/after-i-post/">After I Post</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/clip-bot/">Clip Bot</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/newsletter-cleanup/">Newsletter Cleanup</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/account-research-desk/">Account Research Desk</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/influencer-marketing-deal-desk/">Influencer Marketing Deal Desk</a></li><li><a class="inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary" href="/bots/human-copywriter/">Human Copywriter</a></li></ul><ul class="mt-6 flex flex-wrap gap-x-4 gap-y-2"><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Content">Content</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Design">Design</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Engineering">Engineering</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Family">Family</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Finance">Finance</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Marketing">Marketing</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Ops">Ops</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Personal">Personal</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Productivity">Productivity</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Research">Research</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=Sales">Sales</a></li><li><a class="font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary" href="/bots/?tag=SEO">SEO</a></li></ul></section><section class="mx-auto max-w-6xl px-5 py-10" aria-labelledby="brief-heading"><div class="grid gap-8 rounded-3xl border border-primary/30 bg-card px-6 py-8 md:grid-cols-[1.1fr_1fr] md:px-10 md:py-10"><div><p class="font-mono text-[11px] tracking-[0.18em] text-primary uppercase">The brief</p><h2 id="brief-heading" class="mt-2 font-display text-4xl tracking-tight md:text-5xl">Filed when there is something worth filing.</h2><p class="mt-4 max-w-md text-base leading-7 text-muted-foreground">Desk Signal is the newsletter for the roster. New bots, jobs worth handing off, and what to ignore. Irregular on purpose.</p></div><form class="flex flex-col gap-3" action="https://buttondown.com/api/emails/embed-subscribe/desksignal" method="post"><div class="flex flex-col gap-2"><label for="home-email" class="font-mono text-[11px] tracking-[0.16em] text-muted-foreground uppercase">Email</label><div class="flex flex-col gap-2 sm:flex-row"><input id="home-email" type="email" data-slot="input" required="" autoComplete="email" inputMode="email" placeholder="you@company.com" class="w-full min-w-0 rounded-lg border border-input py-1 transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 h-12 bg-background px-3.5 text-base md:text-base" name="email"/><button type="submit" tabindex="0" data-slot="button" class="group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&amp;_svg]:pointer-events-none [&amp;_svg]:shrink-0 [&amp;_svg:not([class*=&#x27;size-&#x27;])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-12 px-5 sm:px-6">Subscribe</button></div></div><input type="hidden" name="embed" value="1"/><p class="text-sm leading-6 text-muted-foreground">Posts to the Buttondown list <span class="text-foreground">desksignal</span>. A confirm email follows. No account on this site.<!-- --> <a href="https://buttondown.com/desksignal/archive" class="text-foreground underline-offset-4 hover:underline">Read the archive</a>.</p></form></div></section></div><!--$--><!--/$--></main><footer class="mt-20 border-t border-border"><div class="mx-auto grid max-w-6xl gap-8 px-5 py-10 sm:grid-cols-[1.4fr_1fr]"><div><p class="font-display text-2xl tracking-tight">Desk Signal</p><p class="mt-2 max-w-sm text-sm leading-6 text-muted-foreground">A growing roster and a short brief. Listings point at templates other people published. This desk does not run them.</p></div><div class="flex flex-col gap-2 text-sm sm:items-end"><nav aria-label="Footer" class="flex flex-wrap gap-x-4 gap-y-2 sm:justify-end"><a class="text-muted-foreground hover:text-foreground" href="/bots/">Directory</a><a class="text-muted-foreground hover:text-foreground" href="/archive/">Archive</a><a class="text-muted-foreground hover:text-foreground" href="/sponsor/">Sponsor</a><a class="text-muted-foreground hover:text-foreground" href="/subscribe/">Subscribe</a><a class="text-muted-foreground hover:text-foreground" href="/about/">About</a></nav><a href="https://buttondown.com/desksignal/archive" class="text-muted-foreground underline-offset-4 hover:text-foreground hover:underline">Newsletter archive</a></div></div><div class="border-t border-border"><p class="mx-auto flex max-w-6xl flex-wrap items-center justify-between gap-2 px-5 py-4 font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase"><span>Faceless desk. No byline.</span><span>© <!-- -->2026<!-- --> Desk Signal</span></p></div></footer><script src="/_next/static/chunks/310vm2bl3xxpt.js" id="_R_" async=""></script><script>(self.__next_f=self.__next_f||[]).push([0])</script><script>self.__next_f.push([1,"1:\"$Sreact.fragment\"\n2:I[22016,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\",\"/_next/static/chunks/3s-ohew_744__.js\",\"/_next/static/chunks/33iik9j94mehk.js\"],\"\"]\n3:I[5589,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"NavLink\"]\nb:I[68027,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"default\",1]\n:HL[\"/_next/static/chunks/2t5ahqdst-y4r.css\",\"style\"]\n:HL[\"/_next/static/media/5f402bd2d8eef81a-s.p.40bho2kviej2o.woff2\",\"font\",{\"crossOrigin\":\"\",\"type\":\"font/woff2\"}]\n:HL[\"/_next/static/media/797e433ab948586e-s.p.0r6juujl39pe6.woff2\",\"font\",{\"crossOrigin\":\"\",\"type\":\"font/woff2\"}]\n:HL[\"/_next/static/media/9433d1a810498265-s.p.1hij5ex6k3v9q.woff2\",\"font\",{\"crossOrigin\":\"\",\"type\":\"font/woff2\"}]\n:HL[\"/_next/static/media/caa3a2e1cccd8315-s.p.0wgildi0cnwt9.woff2\",\"font\",{\"crossOrigin\":\"\",\"type\":\"font/woff2\"}]\n0:{\"P\":null,\"c\":[\"\",\"\"],\"q\":\"\",\"i\":false,\"f\":[[[\"\",{\"children\":[\"__PAGE__\",{},\"$undefined\",\"$undefined\",4608]},\"$undefined\",\"$undefined\",4624],[[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/chunks/2t5ahqdst-y4r.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\",\"nonce\":\"$undefined\"}],[\"$\",\"script\",\"script-0\",{\"src\":\"/_next/static/chunks/2m08nx5b09w44.js\",\"async\":true,\"nonce\":\"$undefined\"}],[\"$\",\"script\",\"script-1\",{\"src\":\"/_next/static/chunks/2aq5wibyuj2l2.js\",\"async\":true,\"nonce\":\"$undefined\"}]],[\"$\",\"html\",null,{\"lang\":\"en\",\"className\":\"geist_a71539c9-module__T19VSG__variable geist_mono_8d43a2aa-module__8Li5zG__variable newsreader_4c79f885-module__QbPzfW__variable dark h-full antialiased\",\"children\":[\"$\",\"body\",null,{\"className\":\"flex min-h-full flex-col\",\"children\":[[\"$\",\"div\",null,{\"className\":\"h-1 bg-primary\"}],[\"$\",\"header\",null,{\"className\":\"sticky top-0 z-40 border-b border-border/80 bg-background/85 backdrop-blur-md\",\"children\":[[\"$\",\"a\",null,{\"href\":\"#content\",\"className\":\"sr-only focus:not-sr-only focus:absolute focus:top-3 focus:left-4 focus:z-50 focus:rounded-md focus:bg-primary focus:px-3 focus:py-2 focus:text-sm focus:text-primary-foreground\",\"children\":\"Skip to content\"}],[\"$\",\"div\",null,{\"className\":\"mx-auto flex h-16 max-w-6xl items-center justify-between gap-4 px-5\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/\",\"className\":\"flex items-center gap-2.5 text-foreground\",\"children\":[[\"$\",\"svg\",null,{\"aria-hidden\":\"true\",\"viewBox\":\"0 0 32 32\",\"className\":\"size-8\",\"children\":[[\"$\",\"rect\",null,{\"width\":\"32\",\"height\":\"32\",\"rx\":\"6\",\"fill\":\"#B8F255\"}],[\"$\",\"rect\",null,{\"x\":\"7\",\"y\":\"18\",\"width\":\"4\",\"height\":\"7\",\"fill\":\"#0B0F14\"}],[\"$\",\"rect\",null,{\"x\":\"14\",\"y\":\"13\",\"width\":\"4\",\"height\":\"12\",\"fill\":\"#0B0F14\"}],[\"$\",\"rect\",null,{\"x\":\"21\",\"y\":\"7\",\"width\":\"4\",\"height\":\"18\",\"fill\":\"#0B0F14\"}]]}],[\"$\",\"span\",null,{\"className\":\"font-display text-xl leading-none tracking-tight\",\"children\":\"Desk Signal\"}]]}],[\"$\",\"nav\",null,{\"aria-label\":\"Primary\",\"className\":\"hidden items-center gap-6 md:flex\",\"children\":[[\"$\",\"$L3\",\"/bots/\",{\"href\":\"/bots/\",\"children\":\"Directory\"}],[\"$\",\"$L3\",\"/archive/\",{\"href\":\"/archive/\",\"children\":\"Archive\"}],[\"$\",\"$L3\",\"/sponsor/\",{\"href\":\"/sponsor/\",\"children\":\"Sponsor\"}],[\"$\",\"$L3\",\"/about/\",{\"href\":\"/about/\",\"children\":\"About\"}]]}],[\"$\",\"div\",null,{\"className\":\"flex items-center gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/subscribe/\",\"className\":\"group/button shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-9 px-3.5 hidden sm:inline-flex\",\"children\":\"Subscribe\"}],[\"$\",\"details\",null,{\"className\":\"group relative md:hidden\",\"children\":[[\"$\",\"summary\",null,{\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-9 cursor-pointer list-none px-3 [\u0026::-webkit-details-marker]:hidden\",\"children\":[\"$L4\",\"$L5\"]}],\"$L6\"]}]]}]]}]]}],\"$L7\",\"$L8\"]}]}]]}],{\"children\":[\"$L9\",{},null,false,null]},null,false,null],\"$La\",false]],\"m\":\"$undefined\",\"G\":[\"$b\",[\"$Lc\"]],\"S\":true,\"h\":null,\"r\":\"$undefined\",\"s\":\"$undefined\",\"a\":\"$undefined\",\"l\":\"$undefined\",\"p\":\"$undefined\",\"d\":\"$undefined\",\"b\":\"IFiyd_98unu-BC2lgcqYU\"}\nd:I[5014,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"default\"]\ne:I[39756,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"default\"]\nf:I[37457,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"default\"]\n10:I[58300,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\",\"/_next/static/chunks/3s-ohew_744__.js\",\"/_next/static/chunks/33iik9j94mehk.js\"],\"Input\"]\n11:I[56151,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\",\"/_next/static/chunks/3s-ohew_744__.js\",\"/_next/static/chunks/33iik9j94mehk.js\"],\"NewToday\"]\n18:I[97367,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"ViewportBoundary\"]\n1a:I[97367,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"MetadataBoundary\"]\n1b:\"$Sreact.suspense\"\n4:[\"$\",\"$Ld\",null,{\"ref\":\"$undefined\",\"icon\":{\"name\":\"menu\",\"size\":24,\"node\":[[\"path\",{\"d\":\"M4 5h16\",\"key\":\"1tepv9\"}],[\"path\",{\"d\":\"M4 12h16\",\"key\":\"1lakjw\"}],[\"path\",{\"d\":\"M4 19h16\",\"key\":\"1djgab\"}]]},\"className\":\"$undefined\",\"aria-hidden\":\"true\"}]\n5:[\"$\",\"span\",null,{\"className\":\"sr-only\",\"children\":\"Open menu\"}]\n6:[\"$\",\"nav\",null,{\"aria-label\":\"Mobile\",\"className\":\"absolute right-0 mt-2 w-52 rounded-xl border border-border bg-card p-2 shadow-2xl\",\"children\":[[[\"$\",\"$L3\",\"/bots/\",{\"href\":\"/bots/\",\"className\":\"block rounded-lg px-3 py-2.5 hover:bg-muted\",\"children\":\"Directory\"}],[\"$\",\"$L3\",\"/archive/\",{\"href\":\"/archive/\",\"className\":\"block rounded-lg px-3 py-2.5 hover:bg-muted\",\"children\":\"Archive\"}],[\"$\",\"$L3\",\"/sponsor/\",{\"href\":\"/sponsor/\",\"className\":\"block rounded-lg px-3 py-2.5 hover:bg-muted\",\"children\":\"Sponsor\"}],[\"$\",\"$L3\",\"/about/\",{\"href\":\"/about/\",\"className\":\"block rounded-lg px-3 py-2.5 hover:bg-muted\",\"children\":\"About\"}]],[\"$\",\"$L2\",null,{\"href\":\"/subscribe/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-9 px-3.5 mt-1 w-full sm:hidden\",\"children\":\"Subscribe\"}]]}]\n7:[\"$\",\"main\",null,{\"id\":\"content\",\"className\":\"flex-1\",\"children\":[\"$\",\"$Le\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$Lf\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":[[\"$\",\"div\",null,{\"className\":\"mx-auto max-w-3xl px-5 pt-20 pb-8\",\"children\":[[\"$\",\"p\",null,{\"className\":\"font-mono text-[11px] tracking-[0.18em] text-primary uppercase\",\"children\":\"404\"}],[\"$\",\"h1\",null,{\"className\":\"mt-2 font-display text-5xl tracking-tight\",\"children\":\"That page is not on the desk.\"}],[\"$\",\"p\",null,{\"className\":\"mt-4 text-muted-foreground\",\"children\":\"The roster and the brief are still here.\"}],[\"$\",\"div\",null,{\"className\":\"mt-8 flex flex-wrap gap-3\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-11 px-4\",\"children\":\"Home\"}],[\"$\",\"$L2\",null,{\"href\":\"/bots/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-11 px-4\",\"children\":\"Directory\"}]]}]]}],[]],\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]}]\n8:[\"$\",\"footer\",null,{\"className\":\"mt-20 border-t border-border\",\"children\":[[\"$\",\"div\",null,{\"className\":\"mx-auto grid max-w-6xl gap-8 px-5 py-10 sm:grid-cols-[1.4fr_1fr]\",\"children\":[[\"$\",\"div\",null,{\"children\":[[\"$\",\"p\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":\"Desk Signal\"}],[\"$\",\"p\",null,{\"className\":\"mt-2 max-w-sm text-sm leading-6 text-muted-foreground\",\"children\":\"A growing roster and a short brief. Listings point at templates other people published. This desk does not run them.\"}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-col gap-2 text-sm sm:items-end\",\"children\":[[\"$\",\"nav\",null,{\"aria-label\":\"Footer\",\"className\":\"flex flex-wrap gap-x-4 gap-y-2 sm:justify-end\",\"children\":[[\"$\",\"$L2\",\"/bots/\",{\"href\":\"/bots/\",\"className\":\"text-muted-foreground hover:text-foreground\",\"children\":\"Directory\"}],[\"$\",\"$L2\",\"/archive/\",{\"href\":\"/archive/\",\"className\":\"text-muted-foreground hover:text-foreground\",\"children\":\"Archive\"}],[\"$\",\"$L2\",\"/sponsor/\",{\"href\":\"/sponsor/\",\"className\":\"text-muted-foreground hover:text-foreground\",\"children\":\"Sponsor\"}],[\"$\",\"$L2\",\"/subscribe/\",{\"href\":\"/subscribe/\",\"className\":\"text-muted-foreground hover:text-foreground\",\"children\":\"Subscribe\"}],[\"$\",\"$L2\",\"/about/\",{\"href\":\"/about/\",\"className\":\"text-muted-foreground hover:text-foreground\",\"children\":\"About\"}]]}],[\"$\",\"a\",null,{\"href\":\"https://buttondown.com/desksignal/archive\",\"className\":\"text-muted-foreground underline-offset-4 hover:text-foreground hover:underline\",\"children\":\"Newsletter archive\"}]]}]]}],[\"$\",\"div\",null,{\"className\":\"border-t border-border\",\"children\":[\"$\",\"p\",null,{\"className\":\"mx-auto flex max-w-6xl flex-wrap items-center justify-between gap-2 px-5 py-4 font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase\",\"children\":[[\"$\",\"span\",null,{\"children\":\"Faceless desk. No byline.\"}],[\"$\",\"span\",null,{\"children\":[\"© \",2026,\" Desk Signal\"]}]]}]}]]}]\n9:[\"$\",\"$1\",\"c\",{\"children\":[[\"$\",\"div\",null,{\"children\":[[\"$\",\"section\",null,{\"className\":\"mx-auto max-w-6xl px-5 pt-14 pb-8 md:pt-20\",\"children\":[[\"$\",\"p\",null,{\"className\":\"font-mono text-[11px] tracking-[0.22em] text-primary uppercase\",\"children\":\"New bots, often\"}],[\"$\",\"h1\",null,{\"className\":\"mt-4 max-w-4xl font-display text-[clamp(2.7rem,7vw,5.4rem)] leading-[0.95] tracking-[-0.035em]\",\"children\":[\"What matters if you run a desk of \",[\"$\",\"span\",null,{\"className\":\"text-primary italic\",\"children\":\"Grok Bots\"}],\".\"]}],[\"$\",\"p\",null,{\"className\":\"mt-6 max-w-xl text-lg leading-8 text-muted-foreground\",\"children\":\"A growing roster of installable Grok Bots. New ones are added often, each with a job and a public install link.\"}],[\"$\",\"form\",null,{\"action\":\"/bots/\",\"method\":\"get\",\"role\":\"search\",\"className\":\"mt-8 max-w-2xl\",\"children\":[[\"$\",\"label\",null,{\"htmlFor\":\"home-search\",\"className\":\"sr-only\",\"children\":\"Search bots\"}],[\"$\",\"div\",null,{\"className\":\"flex flex-col gap-2 sm:flex-row\",\"children\":[[\"$\",\"$L10\",null,{\"type\":\"$undefined\",\"data-slot\":\"input\",\"className\":\"w-full min-w-0 rounded-lg border border-input py-1 transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 h-12 bg-card px-3.5 text-base md:text-base\",\"id\":\"home-search\",\"name\":\"q\",\"placeholder\":\"Search by name, job, tag, or builder\"}],[\"$\",\"button\",null,{\"type\":\"submit\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-12 px-5\",\"children\":\"Search the desk\"}]]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"mx-auto max-w-6xl px-5 pb-2\",\"children\":[\"$\",\"$L11\",null,{\"bots\":[{\"name\":\"last30days\",\"slug\":\"last30days\",\"summary\":\"A 30-day brief of what people actually said, drawn from Reddit, X, YouTube, TikTok, Hacker News, Polymarket, GitHub, and the web.\",\"problem\":\"A desk needs a recent, sourced read on a topic. A model's memory of the topic is the wrong document.\",\"solution\":\"Installs the latest last30days skill, walks first-run setup, and writes a grounded brief. It checks GitHub for a new skill version every 30 days.\",\"installUrl\":\"https://x.ai/bot/ANv3NrqPfRcS9PdXku7h8\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\",\"Marketing\"],\"builderX\":\"mvanhorn\",\"sourceSite\":\"https://grokbots.best/bots/last30days\",\"addedAt\":\"2026-08-29\",\"featured\":true},{\"name\":\"Researchy\",\"slug\":\"researchy\",\"summary\":\"A fact-check desk that runs every pass with live web search and returns sourced, dated claims.\",\"problem\":\"Answers that never leave the training set look finished and are not usable on a live desk.\",\"solution\":\"Runs research and fact-check passes on the latest Grok model with live web search, for work that needs a source and a date on the claim.\",\"installUrl\":\"https://x.ai/bot/rQt4W2zO2Gx9lfcBjd1lj\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\"],\"builderX\":\"farzyness\",\"sourceSite\":\"https://grokbots.best/bots/researchy\",\"addedAt\":\"2026-08-30\",\"featured\":true},{\"name\":\"Research Bot\",\"slug\":\"research-bot\",\"summary\":\"First-principles research that says so when a source was not verified.\",\"problem\":\"An unverified source has to be labeled before anyone downstream treats the paragraph as research.\",\"solution\":\"Reasons from first principles and will not hand back an unverified source without saying so.\",\"installUrl\":\"https://x.ai/bot/Nn0ykGa3vJ6YS7ib7F6yH\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\"],\"builderX\":\"ArthurMacwaters\",\"sourceSite\":\"https://grokbots.best/bots/research-bot\",\"addedAt\":\"2026-08-29\",\"featured\":false},{\"name\":\"X Brief\",\"slug\":\"x-brief\",\"summary\":\"Learns the beat from your recent posts, then files a weekday wrap of what moved.\",\"problem\":\"A generic timeline is not a brief. The desk needs the slice of X it actually watches.\",\"solution\":\"Connects X, infers the beat from recent posts, confirms it, and sends a weekday end-of-day wrap. Post angles only if you ask.\",\"installUrl\":\"https://x.ai/bot/GkX6X536UK2MlbkfGLQnb\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\",\"Content\"],\"builderX\":\"daniel_mac8\",\"sourceSite\":\"https://grokbots.best/bots/x-brief\",\"addedAt\":\"2026-08-29\",\"featured\":false},{\"name\":\"Frontier Model Watch\",\"slug\":\"frontier-model-watch\",\"summary\":\"A morning watch on official model releases. Silent when nothing new dropped.\",\"problem\":\"Model news is constant. Most of it is not a release the desk needs before the day starts.\",\"solution\":\"Watches official releases from xAI, Anthropic, Google, OpenAI, Moonshot, Alibaba, Zhipu, DeepSeek, MiniMax, and Tencent. Sends a short brief only if something new dropped in the last 36 hours: name, use, open or closed, and price if known.\",\"installUrl\":\"https://x.ai/bot/YHqn0iTQuvI-8LC01IP6S\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\",\"Engineering\"],\"builderX\":\"unicodef1wn\",\"sourceSite\":\"https://grokbots.best/bots/frontier-model-watch\",\"addedAt\":\"2026-08-30\",\"featured\":false},{\"name\":\"Overheard\",\"slug\":\"overheard\",\"summary\":\"A weekday digest of third-party mentions of your name, brand, and URLs. Quiet on dead days.\",\"problem\":\"Mention monitoring that pings when nothing happened trains the desk to ignore it.\",\"solution\":\"Watches Reddit, Hacker News, news sites, and X. Sends a short weekday digest when a mention clears the bar. Stays quiet on dead days and never posts on your behalf.\",\"installUrl\":\"https://x.ai/bot/NIEguoGUjA648fUPle8F5\",\"imageUrl\":\"$undefined\",\"tags\":[\"SEO\",\"Productivity\",\"Marketing\"],\"builderX\":\"lennysan\",\"sourceSite\":\"https://grokbots.best/bots/overheard\",\"addedAt\":\"2026-09-05\",\"featured\":false},{\"name\":\"Product Idea Stress Test\",\"slug\":\"product-idea-stress-test\",\"summary\":\"Stress-tests a product or startup idea: what has to be true, the evidence, and the assumption most likely to kill it.\",\"problem\":\"A build starts too early when nobody has named the assumption that would kill the idea.\",\"solution\":\"Investigates a product or startup idea for founders. Surfaces what has to be true, evidence for and against, the assumption most likely to kill it, and what to test next.\",\"installUrl\":\"https://x.ai/bot/JeFTvcDX-7QT2evKGIb52\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\",\"Sales\"],\"builderX\":\"hnshah\",\"sourceSite\":\"https://grokbots.best/bots/product-idea-stress-test\",\"addedAt\":\"2026-08-30\",\"featured\":true},{\"name\":\"Working Backwards PM\",\"slug\":\"working-backwards-pm\",\"summary\":\"Starts from the customer: five questions, a PRFAQ, then a PRD after you align.\",\"problem\":\"A spec that starts from the feature list locks engineering into the wrong cut.\",\"solution\":\"Asks five customer questions, writes a PRFAQ, and writes the PRD after you align. For founders and PMs.\",\"installUrl\":\"https://x.ai/bot/maxOL0-n_PSVuwi5mpZgP\",\"imageUrl\":\"$undefined\",\"tags\":[\"Research\",\"Design\",\"Engineering\"],\"builderX\":\"ccsakuweb\",\"sourceSite\":\"https://grokbots.best/bots/working-backwards-pm\",\"addedAt\":\"2026-10-03\",\"featured\":false},{\"name\":\"Dr Eggbot\",\"slug\":\"dr-eggbot\",\"summary\":\"Designs tight Grok Bots: one job, one voice, and no leftover tools.\",\"problem\":\"A roster gets sloppy when each new bot is a vague assistant with every tool left on.\",\"solution\":\"Asks a few preference questions, then creates the bot with CreateAgent. Coding bots get a verified, one-job bar. Other bots get the same tightness: one job, one voice, explicit anti-jobs, no leftover tools. It does not default to shareable templates.\",\"installUrl\":\"https://x.ai/bot/_jOdbfkB16zxu7MRcmReE\",\"imageUrl\":\"$undefined\",\"tags\":[\"Engineering\",\"Ops\"],\"builderX\":\"poteto\",\"sourceSite\":\"https://grokbots.best/bots/dr-eggbot\",\"addedAt\":\"2026-08-29\",\"featured\":true},{\"name\":\"Alfred (Bot Chief Advisor)\",\"slug\":\"alfred-bot-chief-advisor\",\"summary\":\"Audits the bots you already run and reshapes the roster as the work changes.\",\"problem\":\"The failure mode of a bot desk is adding another assistant while the old ones no longer match the work.\",\"solution\":\"Audits the set you already have and retires or adds bots as the business moves, rather than building one more general assistant.\",\"installUrl\":\"https://x.ai/bot/KZ9xav0Qad1U5QigEn7rh\",\"imageUrl\":\"$undefined\",\"tags\":[\"Ops\"],\"builderX\":\"heyrobinai\",\"sourceSite\":\"https://grokbots.best/bots/alfred-bot-chief-advisor\",\"addedAt\":\"2026-08-29\",\"featured\":true},{\"name\":\"loops\",\"slug\":\"loops\",\"summary\":\"An engineering outer loop above coding agents. You name the repo. It does not guess.\",\"problem\":\"Coding agents drift when nobody writes the goal, the proof, or which repo they are allowed to touch.\",\"solution\":\"Sits above coding agents, uses pstack as the reference for how and why, writes goal-style prompts with testable proof, and runs gather, prompt, launch, review, merge. You name the repo.\",\"installUrl\":\"https://x.ai/bot/Ub3T7usX-c6yRQibQq83P\",\"imageUrl\":\"$undefined\",\"tags\":[\"Engineering\"],\"builderX\":\"Av1dlive\",\"sourceSite\":\"https://grokbots.best/bots/loops\",\"addedAt\":\"2026-08-30\",\"featured\":false},{\"name\":\"tinkabot\",\"slug\":\"tinkabot\",\"summary\":\"Wraps an API into a Cursor or agent plugin: MCP plus skills, smallest scaffold that works.\",\"problem\":\"Plugin work balloons before anyone has proved the data shape on a local machine.\",\"solution\":\"Starts from the data shape, builds the smallest scaffold that works, proves it locally, then asks once about affiliation and publishing to the marketplace or cursor.directory.\",\"installUrl\":\"https://x.ai/bot/br5f3C4mc75QCMEHaszXd\",\"imageUrl\":\"$undefined\",\"tags\":[\"Engineering\"],\"builderX\":\"poteto\",\"sourceSite\":\"https://grokbots.best/bots/tinkabot\",\"addedAt\":\"2026-09-01\",\"featured\":false},{\"name\":\"Lingxi's Engineer Bot\",\"slug\":\"lingxi-s-engineer-bot\",\"summary\":\"Boards engineering work, launches cloud agents, and watches pull requests until you are the one who merges.\",\"problem\":\"Agent supervision turns into babysitting when nobody owns the cadence between board and merge.\",\"solution\":\"A hands-off engineering supervisor. It boards work, launches cloud agents, watches pull requests on a 30-minute cadence, and only asks you to merge.\",\"installUrl\":\"https://x.ai/bot/fY1xWwCLzDDGVe3GwH78j\",\"imageUrl\":\"$undefined\",\"tags\":[\"Engineering\",\"Ops\"],\"builderX\":\"lingxi\",\"sourceSite\":\"https://grokbots.best/bots/lingxi-s-engineer-bot\",\"addedAt\":\"2026-09-01\",\"featured\":false},{\"name\":\"Site Audit\",\"slug\":\"site-audit\",\"summary\":\"Scores a site for SEO, content, speed, accessibility, conversion, and schema, with evidence URLs and a monthly diff.\",\"problem\":\"An audit the desk can act on has scores, priorities, and evidence. Invented metrics do not.\",\"solution\":\"Audits SEO, content, speed, accessibility, conversion, and schema. Returns P0, P1, and P2 with evidence URLs, then diffs the audit monthly. No invented metrics.\",\"installUrl\":\"https://x.ai/bot/s6JVFYDIDMsCQMBeTcznW\",\"imageUrl\":\"$undefined\",\"tags\":[\"SEO\",\"Marketing\"],\"builderX\":\"unicodef1wn\",\"sourceSite\":\"https://grokbots.best/bots/site-audit\",\"addedAt\":\"2026-08-30\",\"featured\":true},{\"name\":\"SEO \u0026 AEO Desk\",\"slug\":\"seo-aeo-desk\",\"summary\":\"Turns a keyword list or Search Console export into content ideas and writer-ready briefs for search and AI answers.\",\"problem\":\"Keywords sit in a sheet while writers wait for a brief they can actually draft from.\",\"solution\":\"Works from a pasted keyword list or Search Console and returns content ideas plus writer-ready briefs for search and AI answers.\",\"installUrl\":\"https://x.ai/bot/0IhyZWxwbf2cFmsmroZQL\",\"imageUrl\":\"$undefined\",\"tags\":[\"SEO\"],\"builderX\":\"adamta\",\"sourceSite\":\"https://grokbots.best/bots/seo-aeo-desk\",\"addedAt\":\"2026-09-06\",\"featured\":false},{\"name\":\"figma bro\",\"slug\":\"figma-bro\",\"summary\":\"Designs in Figma with real components, layout, and motion.\",\"problem\":\"Handoff stalls when the file is a picture of the interface instead of components the build can use.\",\"solution\":\"Designs in Figma: real components, intuitive layout, and motion that feels right.\",\"installUrl\":\"https://x.ai/bot/VHMdjIGjGpgDSJR7dW6Gz\",\"imageUrl\":\"$undefined\",\"tags\":[\"Design\"],\"builderX\":\"johnbai\",\"sourceSite\":\"https://grokbots.best/bots/figma-bro\",\"addedAt\":\"2026-08-31\",\"featured\":false},{\"name\":\"Critiquito\",\"slug\":\"critiquito\",\"summary\":\"Reviews an interface screenshot from the person who has to use it, and picks one highest-impact fix.\",\"problem\":\"A critique that lists everything fixes nothing. The desk needs the one change that matters.\",\"solution\":\"Reviews interface screenshots from the person who has to use them. Names what is unclear, hard, or unforgiving, and picks one highest-impact fix.\",\"installUrl\":\"https://x.ai/bot/rt9m-FTkJoGsZzAjsKLPM\",\"imageUrl\":\"$undefined\",\"tags\":[\"Design\"],\"builderX\":\"mamuso\",\"sourceSite\":\"https://grokbots.best/bots/critiquito\",\"addedAt\":\"2026-08-29\",\"featured\":false},{\"name\":\"Growth Desk\",\"slug\":\"growth-desk\",\"summary\":\"Draft-only growth for one named X account. It does not research the feed, and it does not post.\",\"problem\":\"A growth bot that can post on its own is a liability on a real account.\",\"solution\":\"Drafts for one named account. You grow the account. It does not research the feed and it does not post.\",\"installUrl\":\"https://x.ai/bot/YYCOE-YeGxnGLb4Mbv7dO\",\"imageUrl\":\"$undefined\",\"tags\":[\"Marketing\",\"Content\"],\"builderX\":\"Av1dlive\",\"sourceSite\":\"https://grokbots.best/bots/growth-desk\",\"addedAt\":\"2026-08-30\",\"featured\":false},{\"name\":\"Outbound Prospecting\",\"slug\":\"outbound-prospecting\",\"summary\":\"Finds prospects that match your ideal customer and drafts a first message. Nothing sends without a yes.\",\"problem\":\"Outbound fails when the research is thin, or when a bot is allowed to send.\",\"solution\":\"Finds prospects that match your ideal customer, researches each name on the public web, and drafts the first message. Nothing sends without your yes.\",\"installUrl\":\"https://x.ai/bot/i03IaF768-ielyzegoGye\",\"imageUrl\":\"$undefined\",\"tags\":[\"Sales\"],\"builderX\":\"kristaletz\",\"sourceSite\":\"https://grokbots.best/bots/outbound-prospecting\",\"addedAt\":\"2026-09-06\",\"featured\":false},{\"name\":\"Haggle Bot\",\"slug\":\"haggle-bot\",\"summary\":\"Inventories SaaS spend and drafts vendor counters. It never spends, signs, or sends.\",\"problem\":\"Unused seats and duplicate tools stay in the bill until someone builds the case.\",\"solution\":\"Inventories SaaS spend from Ramp and bills, finds evidence-backed savings (unused seats, duplicates, cheaper alternatives), and drafts vendor counters for review. It never spends, signs, or sends without you.\",\"installUrl\":\"https://x.ai/bot/pwQ612YrX3R0eACnIMlom\",\"imageUrl\":\"$undefined\",\"tags\":[\"Finance\"],\"builderX\":\"$undefined\",\"sourceSite\":\"https://grokbots.best/bots/haggle-bot\",\"addedAt\":\"2026-09-06\",\"featured\":false},{\"name\":\"Ad Spend Watch\",\"slug\":\"ad-spend-watch\",\"summary\":\"Watches ad spend from a pasted export and flags what is breaking before it burns budget.\",\"problem\":\"Spend leaks when nobody is watching the export until the invoice arrives.\",\"solution\":\"Reads a pasted ad export, flags what is breaking, and never pauses a campaign without your yes.\",\"installUrl\":\"https://x.ai/bot/MK5zStpj_As8CsRwg3r6w\",\"imageUrl\":\"$undefined\",\"tags\":[\"Marketing\",\"Finance\"],\"builderX\":\"cruzmiguel000\",\"sourceSite\":\"https://grokbots.best/bots/ad-spend-watch\",\"addedAt\":\"2026-10-05\",\"featured\":true},{\"name\":\"Brake\",\"slug\":\"brake\",\"summary\":\"Finds what is burning Grok Bot usage and names the one repeating job to stop.\",\"problem\":\"Usage burns on a looping job while the desk keeps adding more bots.\",\"solution\":\"Audits what is burning usage and names the single repeating job to stop. One diagnosis, not a second assistant.\",\"installUrl\":\"https://x.ai/bot/ig-dwKjUc7doBIDhiMi9Z\",\"imageUrl\":\"$undefined\",\"tags\":[\"Ops\",\"Finance\"],\"builderX\":\"FantomBuildz\",\"sourceSite\":\"https://grokbots.best/bots/brake\",\"addedAt\":\"2026-10-05\",\"featured\":true},{\"name\":\"Cursor Agent\",\"slug\":\"cursor-agent\",\"summary\":\"Local-only builder that runs cursor-agent CLI on your laptop for experiments and shop-floor CLI work.\",\"problem\":\"Cloud agents are the default for PRs; local experiments still need a tight CLI runner that cannot deploy alone.\",\"solution\":\"Runs cursor-agent CLI on the laptop for experiments. Cloud agents stay the default for GitHub PRs. No deploy, submit, or send without your yes.\",\"installUrl\":\"https://x.ai/bot/z4r7D8iILsTQDf7r7DwKR\",\"imageUrl\":\"$undefined\",\"tags\":[\"Engineering\"],\"builderX\":\"unicodef1wn\",\"sourceSite\":\"https://grokbots.best/bots/cursor-agent\",\"addedAt\":\"2026-10-05\",\"featured\":true},{\"name\":\"AI Search Visibility\",\"slug\":\"ai-search-visibility\",\"summary\":\"Checks whether AI assistants and Google recommend you, and who they name instead.\",\"problem\":\"AEO scoreboards beat another keyword brainstorm when buyers ask AI who to hire.\",\"solution\":\"Starts from buyer questions you actually get asked, then scores whether AI answers and search recommend you — and who they name instead.\",\"installUrl\":\"https://x.ai/bot/BFiw9Y7BzTQ-3jFBAro1X\",\"imageUrl\":\"$undefined\",\"tags\":[\"SEO\"],\"builderX\":\"adamta\",\"sourceSite\":\"https://grokbots.best/bots/ai-search-visibility\",\"addedAt\":\"2026-10-05\",\"featured\":false},{\"name\":\"Projects Manager\",\"slug\":\"projects-manager\",\"summary\":\"Spins up coder, designer, researcher, and writer bots with Notion rows and a shared task board.\",\"problem\":\"Multi-bot desks stall when specialists have no shared board and no project home.\",\"solution\":\"Creates specialist bots, gives each project a Notion row and channel, and lets them claim tasks off a shared board.\",\"installUrl\":\"https://x.ai/bot/FU-Ev6_Ju4lFGWwWRD0GD\",\"imageUrl\":\"$undefined\",\"tags\":[\"Ops\",\"Engineering\"],\"builderX\":\"ericzakariasson\",\"sourceSite\":\"https://grokbots.best/bots/projects-manager\",\"addedAt\":\"2026-10-02\",\"featured\":true},{\"name\":\"Be Happier\",\"slug\":\"be-happier\",\"summary\":\"Weekly email and calendar read that suggests three concrete moves to protect the life you already have.\",\"problem\":\"Happiness advice that adds habits piles more work onto a full calendar.\",\"solution\":\"Looks at email and calendar each week, then suggests three concrete things that would make you happier. Protects existing life; does not invent new habits.\",\"installUrl\":\"https://x.ai/bot/0VC1XzREXRFGe0hVo-JEG\",\"imageUrl\":\"$undefined\",\"tags\":[\"Personal\"],\"builderX\":\"lennysan\",\"sourceSite\":\"https://grokbots.best/bots/be-happier\",\"addedAt\":\"2026-10-01\",\"featured\":false},{\"name\":\"Tradbot\",\"slug\":\"tradbot\",\"summary\":\"Watches personal inbox and calendar so school, family, and household follow-ups stop slipping.\",\"problem\":\"Despite the name it is not a trading bot — household follow-ups still slip through a personal inbox.\",\"solution\":\"Watches your personal inbox and calendar so school items, family plans, and household follow-ups stop slipping through.\",\"installUrl\":\"https://x.ai/bot/uY_7s1TZILVzUeJ9lLOx9\",\"imageUrl\":\"$undefined\",\"tags\":[\"Personal\",\"Family\"],\"builderX\":\"clairevo\",\"sourceSite\":\"https://grokbots.best/bots/tradbot\",\"addedAt\":\"2026-09-30\",\"featured\":false},{\"name\":\"After I Post\",\"slug\":\"after-i-post\",\"summary\":\"Post-publish X follow-through: who and what to act on next, with evidence. Asks before any public action.\",\"problem\":\"Publishing is not the finish line; the desk still needs who to reply to and what to learn.\",\"solution\":\"Follows each X post after publication, surfaces people and ideas worth acting on, and preserves evidence. Asks before any public action.\",\"installUrl\":\"https://x.ai/bot/WfsP3VQPxB46wzL4nMwGN\",\"imageUrl\":\"$undefined\",\"tags\":[\"Marketing\",\"Research\"],\"builderX\":\"hnshah\",\"sourceSite\":\"https://grokbots.best/bots/after-i-post\",\"addedAt\":\"2026-09-23\",\"featured\":false},{\"name\":\"Clip Bot\",\"slug\":\"clip-bot\",\"summary\":\"Cuts captioned social-ready podcast highlights from YouTube and drops the file on your computer.\",\"problem\":\"Long recordings sit unused while the desk needs short clips with captions and a source card.\",\"solution\":\"Cuts social-ready podcast highlights from YouTube: captioned 16:9 clips with karaoke captions and a source card, then drops the file on your computer.\",\"installUrl\":\"https://x.ai/bot/Vk0cnF2c364QxNv-Xip1M\",\"imageUrl\":\"$undefined\",\"tags\":[\"Content\",\"Marketing\"],\"builderX\":\"ThisWeeknAI\",\"sourceSite\":\"https://grokbots.best/bots/clip-bot\",\"addedAt\":\"2026-09-23\",\"featured\":false},{\"name\":\"Newsletter Cleanup\",\"slug\":\"newsletter-cleanup\",\"summary\":\"Triages newsletter clutter into a review page, then unsubscribes on your yes — never silent deletes.\",\"problem\":\"Inbox ops fail when a bot deletes mail without a reviewable decision.\",\"solution\":\"Buckets everything into a review page you can read, then acts on your decisions. Unsubscribes rather than deletes, so nothing disappears silently.\",\"installUrl\":\"https://x.ai/bot/dHd69sBvMG2o3lJa__T7K\",\"imageUrl\":\"$undefined\",\"tags\":[\"Productivity\",\"Personal\"],\"builderX\":\"scheemunai\",\"sourceSite\":\"https://grokbots.best/bots/newsletter-cleanup\",\"addedAt\":\"2026-09-30\",\"featured\":false},{\"name\":\"Account Research Desk\",\"slug\":\"account-research-desk\",\"summary\":\"Pre-call briefs and account plans from the public web plus notes you paste. Nothing sends without you.\",\"problem\":\"Sponsorship and brand calls start cold when nobody wrote who you are meeting.\",\"solution\":\"Researches the companies you sell to and writes the pre-call brief and account plan from the public web and notes you paste. Never sends without you.\",\"installUrl\":\"https://x.ai/bot/O3iqVd_ZrdRtrDJpxcKss\",\"imageUrl\":\"$undefined\",\"tags\":[\"Sales\"],\"builderX\":\"akbaliga96\",\"sourceSite\":\"https://grokbots.best/bots/account-research-desk\",\"addedAt\":\"2026-09-30\",\"featured\":false},{\"name\":\"Influencer Marketing Deal Desk\",\"slug\":\"influencer-marketing-deal-desk\",\"summary\":\"Creator deal desk: paste a quote or brief, get a recommend, price band, and structure across major socials.\",\"problem\":\"Sponsorship pricing stays a gut check until someone builds a reviewable deal desk.\",\"solution\":\"Bring a quote, brief, contract, or budget — get a clear recommend, price band, and deal structure across YouTube, Instagram, TikTok, X, and LinkedIn.\",\"installUrl\":\"https://x.ai/bot/j4jkqrRiTmFz64aiAWFgx\",\"imageUrl\":\"$undefined\",\"tags\":[\"Marketing\",\"Sales\"],\"builderX\":\"itsmattreichard\",\"sourceSite\":\"https://grokbots.best/bots/influencer-marketing-deal-desk\",\"addedAt\":\"2026-09-30\",\"featured\":false},{\"name\":\"Human Copywriter\",\"slug\":\"human-copywriter\",\"summary\":\"Rewrites stiff drafts into human voice with a change list. Invents no facts. Draft-only.\",\"problem\":\"AI-slop in emails, landing pages, and posts costs trust before anyone hits publish.\",\"solution\":\"A human-voice rewrite desk for email, posts, blogs, DMs, landing-page bodies, and PR. American English by default. Draft-only: you get a draft, you publish.\",\"installUrl\":\"https://x.ai/bot/JZAccYtlRFvDSU2CnMnkZ\",\"imageUrl\":\"$undefined\",\"tags\":[\"Content\",\"Marketing\"],\"builderX\":\"$undefined\",\"sourceSite\":\"https://grokbots.best/bots/human-copywriter\",\"addedAt\":\"2026-09-30\",\"featured\":false}]}]}],\"$L12\",\"$L13\",\"$L14\"]}],[\"$L15\",\"$L16\"],\"$L17\"]}]\na:[\"$\",\"$1\",\"h\",{\"children\":[null,[\"$\",\"$L18\",null,{\"children\":\"$L19\"}],[\"$\",\"div\",null,{\"hidden\":true,\"children\":[\"$\",\"$L1a\",null,{\"children\":[\"$\",\"$1b\",null,{\"name\":\"Next.Metadata\",\"children\":\"$L1c\"}]}]}],[\"$\",\"meta\",null,{\"name\":\"next-size-adjust\",\"content\":\"\"}]]}]\nc:[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/chunks/2t5ahqdst-y4r.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\",\"nonce\":\"$undefined\"}]\n2f:I[27930,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\",\"/_next/static/chunks/3s-ohew_744__.js\",\"/_next/static/chunks/33iik9j94mehk.js\"],\"Button\"]\n30:I[97367,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"OutletBoundary\"]\n12:[\"$\",\"section\",null,{\"className\":\"mx-auto max-w-6xl px-5 py-8\",\"aria-labelledby\":\"featured-heading\",\"children\":[[\"$\",\"div\",null,{\"className\":\"mb-5 flex items-end justify-between gap-4\",\"children\":[[\"$\",\"div\",null,{\"children\":[[\"$\",\"p\",null,{\"className\":\"font-mono text-[11px] tracking-[0.18em] text-muted-foreground uppercase\",\"children\":\"On the blotter\"}],[\"$\",\"h2\",null,{\"id\":\"featured-heading\",\"className\":\"mt-1 font-display text-4xl tracking-tight\",\"children\":\"Featured\"}]]}],[\"$\",\"$L2\",null,{\"href\":\"/bots/\",\"className\":\"text-sm text-primary underline-offset-4 hover:underline\",\"children\":\"Full directory\"}]]}],[\"$\",\"div\",null,{\"className\":\"rounded-2xl border border-border bg-card/70 px-4 py-2 sm:px-6\",\"children\":[[\"$\",\"article\",\"last30days\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"01\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/last30days/\",\"className\":\"hover:text-primary\",\"children\":\"last30days\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"A 30-day brief of what people actually said, drawn from Reddit, X, YouTube, TikTok, Hacker News, Polymarket, GitHub, and the web.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Research\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Research\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Research\"}]}],[\"$\",\"li\",\"Marketing\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Marketing\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Marketing\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/mvanhorn\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"mvanhorn\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/last30days/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/ANv3NrqPfRcS9PdXku7h8\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}],\"$L1d\",\"$L1e\",\"$L1f\",\"$L20\",\"$L21\",\"$L22\",\"$L23\",\"$L24\",\"$L25\"]}]]}]\n13:[\"$\",\"section\",null,{\"className\":\"mx-auto max-w-6xl px-5 py-6\",\"aria-labelledby\":\"rest-heading\",\"children\":[[\"$\",\"h2\",null,{\"id\":\"rest-heading\",\"className\":\"font-display text-3xl tracking-tight\",\"children\":\"Also on the desk\"}],[\"$\",\"ul\",null,{\"className\":\"mt-4 flex flex-wrap gap-2\",\"children\":[[\"$\",\"li\",\"research-bot\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/research-bot/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Research Bot\"}]}],[\"$\",\"li\",\"x-brief\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/x-brief/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"X Brief\"}]}],[\"$\",\"li\",\"frontier-model-watch\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/frontier-model-watch/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Frontier Model Watch\"}]}],[\"$\",\"li\",\"overheard\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/overheard/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Overheard\"}]}],[\"$\",\"li\",\"working-backwards-pm\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/working-backwards-pm/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Working Backwards PM\"}]}],[\"$\",\"li\",\"loops\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/loops/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"loops\"}]}],[\"$\",\"li\",\"tinkabot\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/tinkabot/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"tinkabot\"}]}],[\"$\",\"li\",\"lingxi-s-engineer-bot\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/lingxi-s-engineer-bot/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Lingxi's Engineer Bot\"}]}],[\"$\",\"li\",\"seo-aeo-desk\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/seo-aeo-desk/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"SEO \u0026 AEO Desk\"}]}],[\"$\",\"li\",\"figma-bro\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/figma-bro/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"figma bro\"}]}],[\"$\",\"li\",\"critiquito\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/critiquito/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Critiquito\"}]}],[\"$\",\"li\",\"growth-desk\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/growth-desk/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Growth Desk\"}]}],[\"$\",\"li\",\"outbound-prospecting\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/outbound-prospecting/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Outbound Prospecting\"}]}],[\"$\",\"li\",\"haggle-bot\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/haggle-bot/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Haggle Bot\"}]}],[\"$\",\"li\",\"ai-search-visibility\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/ai-search-visibility/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"AI Search Visibility\"}]}],\"$L26\",\"$L27\",\"$L28\",\"$L29\",\"$L2a\",\"$L2b\",\"$L2c\",\"$L2d\"]}],\"$L2e\"]}]\n14:[\"$\",\"section\",null,{\"className\":\"mx-auto max-w-6xl px-5 py-10\",\"aria-labelledby\":\"brief-heading\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-8 rounded-3xl border border-primary/30 bg-card px-6 py-8 md:grid-cols-[1.1fr_1fr] md:px-10 md:py-10\",\"children\":[[\"$\",\"div\",null,{\"children\":[[\"$\",\"p\",null,{\"className\":\"font-mono text-[11px] tracking-[0.18em] text-primary uppercase\",\"children\":\"The brief\"}],[\"$\",\"h2\",null,{\"id\":\"brief-heading\",\"className\":\"mt-2 font-display text-4xl tracking-tight md:text-5xl\",\"children\":\"Filed when there is something worth filing.\"}],[\"$\",\"p\",null,{\"className\":\"mt-4 max-w-md text-base leading-7 text-muted-foreground\",\"children\":\"Desk Signal is the newsletter for the roster. New bots, jobs worth handing off, and what to ignore. Irregular on purpose.\"}]]}],[\"$\",\"form\",null,{\"action\":\"https://buttondown.com/api/emails/embed-subscribe/desksignal\",\"method\":\"post\",\"className\":\"flex flex-col gap-3\",\"children\":[[\"$\",\"div\",null,{\"className\":\"flex flex-col gap-2\",\"children\":[[\"$\",\"label\",null,{\"htmlFor\":\"home-email\",\"className\":\"font-mono text-[11px] tracking-[0.16em] text-muted-foreground uppercase\",\"children\":\"Email\"}],[\"$\",\"div\",null,{\"className\":\"flex flex-col gap-2 sm:flex-row\",\"children\":[[\"$\",\"$L10\",null,{\"type\":\"email\",\"data-slot\":\"input\",\"className\":\"w-full min-w-0 rounded-lg border border-input py-1 transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 h-12 bg-background px-3.5 text-base md:text-base\",\"id\":\"home-email\",\"name\":\"email\",\"required\":true,\"autoComplete\":\"email\",\"inputMode\":\"email\",\"placeholder\":\"you@company.com\"}],[\"$\",\"$L2f\",null,{\"data-slot\":\"button\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-12 px-5 sm:px-6\",\"type\":\"submit\",\"children\":\"Subscribe\"}]]}]]}],[\"$\",\"input\",null,{\"type\":\"hidden\",\"name\":\"embed\",\"value\":\"1\"}],[\"$\",\"p\",null,{\"className\":\"text-sm leading-6 text-muted-foreground\",\"children\":[\"Posts to the Buttondown list \",[\"$\",\"span\",null,{\"className\":\"text-foreground\",\"children\":\"desksignal\"}],\". A confirm email follows. No account on this site.\",\" \",[\"$\",\"a\",null,{\"href\":\"https://buttondown.com/desksignal/archive\",\"className\":\"text-foreground underline-offset-4 hover:underline\",\"children\":\"Read the archive\"}],\".\"]}]]}]]}]}]\n15:[\"$\",\"script\",\"script-0\",{\"src\":\"/_next/static/chunks/3s-ohew_744__.js\",\"async\":true,\"nonce\":\"$undefined\"}]\n16:[\"$\",\"script\",\"script-1\",{\"src\":\"/_next/static/chunks/33iik9j94mehk.js\",\"async\":true,\"nonce\":\"$undefined\"}]\n17:[\"$\",\"$L30\",null,{\"children\":[\"$\",\"$1b\",null,{\"name\":\"Next.MetadataOutlet\",\"children\":\"$@31\"}]}]\n1d:[\"$\",\"article\",\"researchy\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"02\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/researchy/\",\"className\":\"hover:text-primary\",\"children\":\"Researchy\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"A fact-check desk that runs every pass with live web search and returns sourced, dated claims.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Research\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Research\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Research\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/farzyness\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"farzyness\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/researchy/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/rQt4W2zO2Gx9lfcBjd1lj\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n1e:[\"$\",\"article\",\"product-idea-stress-test\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"03\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/product-idea-stress-test/\",\"className\":\"hover:text-primary\",\"children\":\"Product Idea Stress Test\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Stress-tests a product or startup idea: what has to be true, the evidence, and the assumption most likely to kill it.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Research\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Research\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Research\"}]}],[\"$\",\"li\",\"Sales\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Sales\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Sales\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/hnshah\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"hnshah\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/product-idea-stress-test/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/JeFTvcDX-7QT2evKGIb52\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n1f:[\"$\",\"article\",\"dr-eggbot\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"04\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/dr-eggbot/\",\"className\":\"hover:text-primary\",\"children\":\"Dr Eggbot\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Designs tight Grok Bots: one job, one voice, and no leftover tools.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Engineering\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Engineering\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Engineering\"}]}],[\"$\",\"li\",\"Ops\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Ops\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Ops\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/poteto\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"poteto\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/dr-eggbot/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/_jOdbfkB16zxu7MRcmReE\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n20:[\"$\",\"article\",\"alfred-bot-chief-advisor\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"05\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/alfred-bot-chief-advisor/\",\"className\":\"hover:text-primary\",\"children\":\"Alfred (Bot Chief Advisor)\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Audits the bots you already run and reshapes the roster as the work changes.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Ops\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Ops\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Ops\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/heyrobinai\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"heyrobinai\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/alfred-bot-chief-advisor/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/KZ9xav0Qad1U5QigEn7rh\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n21:[\"$\",\"article\",\"site-audit\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"06\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/site-audit/\",\"className\":\"hover:text-primary\",\"children\":\"Site Audit\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Scores a site for SEO, content, speed, accessibility, conversion, and schema, with evidence URLs and a monthly diff.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"SEO\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=SEO\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"SEO\"}]}],[\"$\",\"li\",\"Marketing\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Marketing\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Marketing\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/unicodef1wn\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"unicodef1wn\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/site-audit/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/s6JVFYDIDMsCQMBeTcznW\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n22:[\"$\",\"article\",\"ad-spend-watch\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"07\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/ad-spend-watch/\",\"className\":\"hover:text-primary\",\"children\":\"Ad Spend Watch\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Watches ad spend from a pasted export and flags what is breaking before it burns budget.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Marketing\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Marketing\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Marketing\"}]}],[\"$\",\"li\",\"Finance\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Finance\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Finance\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/cruzmiguel000\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"cruzmiguel000\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/ad-spend-watch/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/MK5zStpj_As8CsRwg3r6w\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n23:[\"$\",\"article\",\"brake\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"08\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/brake/\",\"className\":\"hover:text-primary\",\"children\":\"Brake\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Finds what is burning Grok Bot usage and names the one repeating job to stop.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Ops\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Ops\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Ops\"}]}],[\"$\",\"li\",\"Finance\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Finance\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Finance\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/FantomBuildz\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"FantomBuildz\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/brake/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/ig-dwKjUc7doBIDhiMi9Z\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n24:[\"$\",\"article\",\"cursor-agent\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"09\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/cursor-agent/\",\"className\":\"hover:text-primary\",\"children\":\"Cursor Agent\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Local-only builder that runs cursor-agent CLI on your laptop for experiments and shop-floor CLI work.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Engineering\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Engineering\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Engineering\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/unicodef1wn\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"unicodef1wn\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/cursor-agent/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/z4r7D8iILsTQDf7r7DwKR\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n25:[\"$\",\"article\",\"projects-manager\",{\"className\":\"border-b border-border py-5 first:pt-0 last:border-b-0\",\"children\":[\"$\",\"div\",null,{\"className\":\"grid gap-4 md:grid-cols-[auto_minmax(0,1fr)_auto] md:items-start md:gap-6\",\"children\":[[\"$\",\"span\",null,{\"className\":\"font-mono text-xs text-primary tabular-nums\",\"children\":\"10\"}],[\"$\",\"div\",null,{\"className\":\"min-w-0\",\"children\":[[\"$\",\"h3\",null,{\"className\":\"font-display text-2xl tracking-tight\",\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/projects-manager/\",\"className\":\"hover:text-primary\",\"children\":\"Projects Manager\"}]}],[\"$\",\"p\",null,{\"className\":\"mt-1.5 max-w-2xl text-sm leading-6 text-muted-foreground\",\"children\":\"Spins up coder, designer, researcher, and writer bots with Notion rows and a shared task board.\"}],[\"$\",\"ul\",null,{\"className\":\"mt-3 flex flex-wrap gap-1.5\",\"children\":[[\"$\",\"li\",\"Ops\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Ops\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Ops\"}]}],[\"$\",\"li\",\"Engineering\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Engineering\",\"className\":\"rounded-full border border-border px-2 py-0.5 font-mono text-[10px] tracking-[0.12em] text-muted-foreground uppercase hover:border-primary hover:text-primary\",\"children\":\"Engineering\"}]}]]}]]}],[\"$\",\"div\",null,{\"className\":\"flex flex-wrap items-center gap-3 md:flex-col md:items-end\",\"children\":[[\"$\",\"a\",null,{\"href\":\"https://x.com/ericzakariasson\",\"className\":\"font-mono text-xs text-muted-foreground hover:text-foreground\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[\"@\",\"ericzakariasson\"]}],[\"$\",\"div\",null,{\"className\":\"flex gap-2\",\"children\":[[\"$\",\"$L2\",null,{\"href\":\"/bots/projects-manager/\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"children\":\"Details\"}],[\"$\",\"a\",null,{\"href\":\"https://x.ai/bot/FU-Ev6_Ju4lFGWwWRD0GD\",\"className\":\"group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [\u0026_svg]:pointer-events-none [\u0026_svg]:shrink-0 [\u0026_svg:not([class*='size-'])]:size-4 bg-primary text-primary-foreground hover:bg-primary/80 gap-1.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2 h-8 px-3\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Install\"}]]}]]}]]}]}]\n26:[\"$\",\"li\",\"be-happier\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/be-happier/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Be Happier\"}]}]\n27:[\"$\",\"li\",\"tradbot\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/tradbot/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Tradbot\"}]}]\n28:[\"$\",\"li\",\"after-i-post\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/after-i-post/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"After I Post\"}]}]\n29:[\"$\",\"li\",\"clip-bot\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/clip-bot/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Clip Bot\"}]}]\n2a:[\"$\",\"li\",\"newsletter-cleanup\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/newsletter-cleanup/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Newsletter Cleanup\"}]}]\n2b:[\"$\",\"li\",\"account-research-desk\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/account-research-desk/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Account Research Desk\"}]}]\n2c:[\"$\",\"li\",\"influencer-marketing-deal-desk\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/influencer-marketing-deal-desk/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Influencer Marketing Deal Desk\"}]}]\n2d:[\"$\",\"li\",\"human-copywriter\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/human-copywriter/\",\"className\":\"inline-flex rounded-full border border-border bg-card px-3 py-1.5 text-sm hover:border-primary hover:text-primary\",\"children\":\"Human Copywriter\"}]}]\n2e:[\"$\",\"ul\",null,{\"className\":\"mt-6 flex flex-wrap gap-x-4 gap-y-2\",\"children\":[[\"$\",\"li\",\"Content\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Content\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Content\"}]}],[\"$\",\"li\",\"Design\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Design\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Design\"}]}],[\"$\",\"li\",\"Engineering\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Engineering\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Engineering\"}]}],[\"$\",\"li\",\"Family\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Family\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Family\"}]}],[\"$\",\"li\",\"Finance\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Finance\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Finance\"}]}],[\"$\",\"li\",\"Marketing\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Marketing\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Marketing\"}]}],[\"$\",\"li\",\"Ops\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Ops\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Ops\"}]}],[\"$\",\"li\",\"Personal\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Personal\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Personal\"}]}],[\"$\",\"li\",\"Productivity\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Productivity\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Productivity\"}]}],[\"$\",\"li\",\"Research\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Research\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Research\"}]}],[\"$\",\"li\",\"Sales\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=Sales\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"Sales\"}]}],[\"$\",\"li\",\"SEO\",{\"children\":[\"$\",\"$L2\",null,{\"href\":\"/bots/?tag=SEO\",\"className\":\"font-mono text-[11px] tracking-[0.14em] text-muted-foreground uppercase hover:text-primary\",\"children\":\"SEO\"}]}]]}]\n19:[[\"$\",\"meta\",\"0\",{\"charSet\":\"utf-8\"}],[\"$\",\"meta\",\"1\",{\"name\":\"viewport\",\"content\":\"width=device-width, initial-scale=1\"}]]\n32:I[27201,[\"/_next/static/chunks/2m08nx5b09w44.js\",\"/_next/static/chunks/2aq5wibyuj2l2.js\"],\"IconMark\"]\n1c:[[\"$\",\"title\",\"0\",{\"children\":\"Desk Signal\"}],[\"$\",\"meta\",\"1\",{\"name\":\"description\",\"content\":\"What matters if you run a desk of Grok Bots. A growing roster of installable templates, with new bots added often.\"}],[\"$\",\"meta\",\"2\",{\"name\":\"application-name\",\"content\":\"Desk Signal\"}],[\"$\",\"link\",\"3\",{\"rel\":\"canonical\",\"href\":\"https://grokbotdesksignal.com/\"}],[\"$\",\"meta\",\"4\",{\"property\":\"og:title\",\"content\":\"Desk Signal\"}],[\"$\",\"meta\",\"5\",{\"property\":\"og:description\",\"content\":\"A growing roster of installable Grok Bots. New bots are added often, plus a short brief for the desk.\"}],[\"$\",\"meta\",\"6\",{\"property\":\"og:url\",\"content\":\"https://grokbotdesksignal.com/\"}],[\"$\",\"meta\",\"7\",{\"property\":\"og:site_name\",\"content\":\"Desk Signal\"}],[\"$\",\"meta\",\"8\",{\"property\":\"og:locale\",\"content\":\"en_US\"}],[\"$\",\"meta\",\"9\",{\"property\":\"og:type\",\"content\":\"website\"}],[\"$\",\"meta\",\"10\",{\"name\":\"twitter:card\",\"content\":\"summary\"}],[\"$\",\"meta\",\"11\",{\"name\":\"twitter:title\",\"content\":\"Desk Signal\"}],[\"$\",\"meta\",\"12\",{\"name\":\"twitter:description\",\"content\":\"A growing roster of installable Grok Bots. New bots are added often, plus a short brief for the desk.\"}],[\"$\",\"link\",\"13\",{\"rel\":\"icon\",\"href\":\"/icon.svg?icon.2o97jvew717xv.svg\",\"sizes\":\"any\",\"type\":\"image/svg+xml\"}],[\"$\",\"$L32\",\"14\",{}]]\n31:null\n"])</script></body></html>