What I'm watching

Static skill packs rot the week after you install them. Founders running Claude Code all day need the harness to keep its own playbooks current from real work — not another dump of SKILL.md files and not a separate labeling job. AutoHarness is that missing lifecycle: learn, fold, graduate, archive.

Most teams still choose between brittle selectors and expensive always-on agent runs. e2e gives founders both: agents write the hard paths once, CI stays cheap on replay, and failures stay readable when the product actually changed. That is the missing layer between Playwright scripts and chat-driven browser demos.

Founders copy product ideas by guessing from the UI. REA lets the agent inspect a real app — even without source — explain how a feature works with evidence, then rebuild a version for your stack in the same session. That is a capability gap no generic coding harness fills: investigation tools under the agent, not another chat wrapper.

Every model defaults to the same SaaS look: Inter, purple gradients, nested cards, gray on color. Thin “frontend skill” packs tell the agent what to avoid; Impeccable turns that into a repeatable workflow with product context, named commands, and rules that run without an API key. Founders shipping agent-built UI get fewer generic screens and a way to keep taste consistent across the team’s tools.

Agent stacks already glue five SDKs and five keys just to search, enrich, and scrape. Monid collapses that surface: discover ranks endpoints by job fit with live health and latency, then run settles usage on the raw response so empty or failed vendor results do not get billed like success. Founders shipping agents care about that more than another model router.

Context rot is the daily tax of shipping with coding agents. Most stacks either compress tokens after the damage or beg you to start a new chat. Context Mode fixes it at the source: keep bulk data off the wire into the model, keep session memory local, and stretch a useful session from tens of minutes into hours without a cloud middleman.

Most agent safety today is soft: classifiers, PII detectors, or hope the model behaves. Founders shipping agents that touch customer data need a hard gate that does not flake. OpenAPPA is that gate — policy you can replay in CI, not a vibe check at runtime.

If you run more than one coding agent, model config is a tax. magpie kills the dance of editing settings.json, config.toml, and opencode files by hand, and it lets one subscription feed the rest of your stack. That is daily leverage for anyone shipping with agents, not another harness.

If your product answers questions over long PDFs, vector RAG still misses the section that matters and returns lookalike paragraphs. PageIndex is a different retrieval job: structure first, then reason. That is the unlock founders need for reliable doc agents without babysitting chunk sizes.

Founders still hand video work to editors or fight Remotion timelines while agents write the rest of the product. HyperFrames closes that gap: agents author seekable HTML compositions, lint them, preview, and render stable MP4s with the same tools they already use for code.

Founders already run fleets of coding agents and lose the thread: which tab owns which task, who spent the budget, what survives a reboot. Paperclip turns that mess into a task manager with company structure — review gates, monthly budgets that stop runaway loops, and portable org templates you can export without leaking secrets.

Log-based spend tools answer how much you spent. They miss the request-time prefix that never lands in the transcript: injected schemas, MCP catalogs, reminders. That invisible half of the context is often what bloats the bill and crowds the window. Founders running heavy agent days need to know which MCP is dead weight and which tool call owns the dollars.

Real agent work dies on tool access. Semrush, Apollo, Crunchbase and friends cost monthly seats nobody buys for a single run, and sharing keys across Claude Code, Codex, and CI is a mess. Model routers fix which LLM you call. Treg fixes which capability the agent can touch without ten signups or leaking credentials into every session.

Founders shipping multi-agent products hit the same wall: untrusted loops that burn money, leak network access, and cannot pause cleanly. Coding harnesses and in-process SDKs do not solve fleet isolation at scale. AX treats agents like Kubernetes treated containers — declarative specs, sandboxes, gateways, and ops verbs you already know. That is infrastructure, not another terminal coding agent.

Founders building finance, ops, and BI products still glue Excel parsers to chat agents and hope the grid stays coherent. Univer is the missing surface: embed real editable office UIs, let agents hit the same APIs server-side, then let people review worktree drafts before merge. That is product infrastructure, not another coding TUI.

Most agent stacks still burn a full LLM call to classify a ticket, then hope the JSON comes back clean. Founders shipping support, ops, and risk pipelines need fast, calibrated labels without hallucinated free text. Laya is that layer: milliseconds, typed outputs, multilingual out of the box — the cheap System 1 beside your slower planner.

Most AI UI demos still dump raw JSX or markdown and hope nothing breaks. Founders shipping agent dashboards, copilots, and personalized product surfaces need the opposite: dynamic screens that stay on-brand and type-checked. json-render is the practical middle path — AI fills the tree, you own the design system — and it is already packaged for the stacks product teams actually ship.

Teams are handing coding agents shell access and API keys with almost no boundary. SkillSpector checks the skills you install; OpenShell is where those agents actually run — filesystem locks, process limits, provider credentials injected only to allowed endpoints, and denials logged instead of silent leaks. That is the missing production gate for founder stacks that already live on Claude Code or Codex.

Founders are installing skill dumps and MCP servers into Claude Code, Codex, and Cursor every week. One bad skill can leak keys or widen agency. Deepsec-style repo audits catch bugs in your app; this catches the plugins you bolt onto the agent before they touch production.

Most agent setups still wake up blank every time you open a new chat. Claude-Mem closes that gap for Claude Code, Codex, OpenCode, Hermes, Copilot, and more: tool use and decisions stick around as searchable memory, so the agent stops relearning your repo politics and unfinished threads from scratch.

Most “research agent” tools are one long chat that forgets the last failed idea. OpenResearch treats research like software: each direction gets its own agent session and worktree, every run is archived to a commit, and logs, diffs, and papers stay tied to the work that produced them — so founders and builders can actually iterate on hypotheses instead of pasting another vague prompt.

Most agent token burn is not the prompt — it is fat git diffs, full test logs, and long ls dumps the model barely needs. RTK cuts that shell noise at the source so Claude Code, Codex, Cursor, and friends stay sharper and cheaper without a new model or a compression gateway.

Coding agents still restyle buttons with random padding and off-theme colors. Soft “taste” skills help, but they do not fail CI. shadcn/lint turns design contracts into Oxlint or ESLint rules so the same loop that fixes TypeScript also pulls UI back onto your system — cheaper correction rounds in their agent evals.

Coding agents ship more diffs than humans can review. Pure agent skills miss files, drift line numbers, and burn tokens. Open Code Review hard-codes selection, bundling, and positioning so the model only does judgment — higher precision at roughly one-ninth the tokens versus a general agent on their bench.

Once agents can hold a long task, the bottleneck is the repo: one dirty tree, path fights, and half your day spent on git worktree add. Worktrunk turns that into short branch-named commands so founders can fan out Claude Code, Codex, or any CLI agent and still merge clean.

Founders still paste a vague ask into chat and get a pretty report with soft citations. Hyperresearch treats research like a product: width sweep, contradiction graphs, adversarial critics, and a hard cite-check before anything ships. Sources land in a searchable vault so the next session starts smarter instead of re-fetching the same web.

Most agent runs still start from a vague chat and hope the code lands. Spec Kit flips that: the spec becomes the source of truth, agents fill the gaps, and converge checks the build against what you actually asked for. If you ship with Copilot, Claude Code, Codex, or Cursor, this is the missing process layer — not another chat wrapper.

Web agents already click browsers. Mobile still breaks most agent loops. If you ship Android, ARTEMIS lets Claude Code, Codex, or Antigravity install a build, walk the UI, grab screenshots and logs, and report failures without a hand-written Appium suite.

Agents write a huge share of your code and leave almost none of the why. When you run Claude Code next to Codex, review becomes archaeology. Atlas keeps the session next to the commit graph so you can ask what changed, who did it, and why — months later.

Most agent demos stop at chat over a product catalog. Real commerce needs search, cart, policy answers, inventory alerts, pricing drafts, and hard gates so writes never hit production without a human. This repo is the blueprint founders can fork instead of inventing safety and skill contracts from scratch.

Provider bills only show a total. Founders running three coding agents never see which model burned the budget on chat instead of code, or which project is eating the month. CodeBurn turns session files already on disk into that breakdown so you can cut waste before the next invoice.

Most agent stacks still treat company knowledge as chunks in a vector store. Utopia puts time and ontology in the base layer: facts carry validity windows, conflicts surface for review, and decisions leave an audit trail on hardware you control.

Founders still hand Claude Code and friends the whole laptop, or they rent brittle cloud sandboxes. ArcBox makes isolation the default on the machine you already use: disposable microVMs with their own kernel, filesystem, and network, while still speaking Docker for everyday containers.

Most coding agents burn one expensive default model on every tool call. Weave Router sits in front of Claude Code, Codex, Cursor, and friends, picks the model per action with a local embedder, and keeps provider keys on your box. Founders get continuity plus a real cost lever, not another key-rotation dashboard.

Founders still rent bloated SEO suites or bounce between half-finished scripts. OpenSEO puts the core workflows in one app you can self-host or pay-as-you-go, then hands the same data to Claude Code, Hermes, and friends over MCP so research stops living only in a browser tab.

Most agent demos chat once and forget. Praxist treats research as a multi-generation process with evaluators, evidence lanes, and a planning panel — so long campaigns stop re-learning the same dead ends and you can inspect why a claim stuck.

Agent UIs still default to the same safe look. Taste Skill is a portable skill pack (not a component library) that forces a design language, hard checks, and redesign audits before code lands — install once, use in Claude Code, Codex, or Cursor.

Most WebGL component kits hide the good stuff behind accounts. ThreeUI Community ships the same shell, live previews, variants, and full free source — so founders can evaluate motion/UI building blocks before paying for Pro.

Coding agents burn tokens rewriting long contexts after every tool call. FreeToken is built for that loop: it serves huge open MoE weights on consumer GPUs and keeps semantic checkpoints so agentic edits can reuse work instead of restarting the prefill tax.

Most agent tools still feel like a private chat with one bot. Cumora treats agents as teammates who claim work, coordinate without stomping each other, and can run on your cloud or your own Claude Code / Codex machine without giving the server your API keys.

Founders lose hours re-finding half-remembered docs, tabs, and PDFs. Cloud bookmark tools are shallow and leaky. Hister keeps the index on machines you control and lets coding agents query it the same way you do, so personal research becomes something the agent can actually use.

Most agent eval stacks make you invent datasets. Real breakage already shows up in production traces with the exact tools and model turns. Founders shipping agents need those failures to become gates, not another dashboard tab you check after the customer complains.

Founders ship drafts, assets, and decks that accumulate invisible Unicode, C2PA bags, and model metadata they never asked for. You need a hygiene layer that agents can call, not a one-off hex edit. This turns provenance cleanup into inspect and clean endpoints with a real skill path.

Every multi-app founder still juggles random ports, broken deep links, and agents that forget which service is on which number. Portless makes local URLs durable so demos, worktrees, and agent tools keep the same hostnames after restarts.

Agent memory is usually a vague retrieval bag that burns tokens and is hard to debug. Founders shipping multi-session agents need a real store they can inspect, tier, and evolve. OpenViking turns context into something you can ls, tree, and audit with a path history.

Companies already filter candidates with AI. Founders and builders still chase roles with spreadsheets and spray-and-pray apps. career-ops turns Claude Code, Codex, OpenCode, and peers into a local filter that ranks fit, kills ghost jobs, and only spends energy on offers that clear a real bar.

Most on-device models still chat. Founders shipping voice, home, and robot products need tiny models that call tools with JSON they can trust, stay offline, and fit in tens of megabytes of RAM. Needle turns that into a single pip package and a single binary engine.

The Grok Bot idea is sticky: a persistent agent with a real desktop. The official one is closed. Rakazo is the same product shape you can self-host, swap models on, and run without a vendor control plane.

Founders already run agents that write files and call APIs. The missing layer is the rest of the stack — Blender, GIMP, Obsidian, QGIS, n8n, game engines — which still expect a human in a GUI. CLI-Anything turns that gap into installable, JSON-speaking harnesses.

Claude Design made artifact-first design feel inevitable, then locked it to one cloud and one model. Founders still need brand-true prototypes, decks, and dashboards without another SaaS tax or closed skill store.