weekend build
Research + production pain
AI agents / reliability
Agents need a recovery layer, not a restart button
A single failed tool call can sink an entire multi-step agent run. The opportunity is a small checkpoint-and-resume layer that lets builders recover from the last good state.
SignalResearch + production pain
PainLong-running agents fail multiplicatively: tool timeouts, bad intermediate state, and missing retry policy compound across the workflow.
EvidenceTemporal has framed agent reliability as a durable execution problem; Microsoft STATE-Bench points at the same missing state discipline. Temporal + STATE-Bench
Already outLangGraph and agent frameworks help orchestrate steps, but recovery, replay, and failure-local state are still left to the app team.
Why nowDurable execution primitives are cheap, and more teams are moving agents from demos into real workflows.
Start hereWrap each agent step in a checkpoint. On failure, replay from the last clean state with a local repair instruction instead of restarting the run.
weekend build
Research + infrastructure gap
AI agents / memory
Agent memory needs expiration dates
Agent memory systems are good at saving facts and bad at knowing when those facts have expired. Stale memory is a quiet product bug waiting to happen.
SignalResearch + infrastructure gap
PainA memory like 'works at Acme' can stay high-confidence after the user changes jobs. Retrieval keeps finding it, and the agent keeps acting on it.
Evidencemem0's State of AI Agent Memory report and Microsoft STATE-Bench both point toward freshness, identity, and contradiction as unresolved memory problems. mem0 + STATE-Bench
Already outMemory frameworks retrieve and summarize well, but few treat facts as versioned records with age, confidence, and supersession.
Why nowA lightweight LLM freshness pass can check important memories against recent context and mark stale facts before they cause bad actions.
Start hereStore every memory with timestamp, confidence, and source. When new context contradicts it, supersede the old fact instead of appending another one.
startup-scale
Market pain
Dev tools / code review
AI code needs a missing-requirements reviewer
AI can write code faster than teams can review it. The gap is not syntax; it is the requirements the prompt never mentioned.
SignalMarket pain
PainAI-generated code often omits auth, validation, permission boundaries, and boring security details because nobody asked for them explicitly.
EvidenceRecent coverage of AI-code review gaps keeps pointing at the same pattern: generated code passes surface checks while missing production constraints. TechCrunch
Already outLinters and copilots catch syntax and common smells. They rarely ask whether the generated diff forgot auth, data retention, or abuse paths.
Why nowEvery AI-authored PR already has machine-readable context: prompt, diff, tests, and app conventions. That is enough for a targeted review agent.
Start hereRun a review pass on each AI-authored PR that checks auth, input validation, secrets, permissions, data retention, and threat-model omissions.
startup-scale
YC RFS
Enterprise agents / knowledge
Every company needs an agent-ready brain
Company knowledge is scattered across Slack, email, tickets, docs, and people's heads. Agents cannot automate work until that know-how becomes structured and executable.
SignalYC RFS
PainSearch and RAG can find documents, but they do not capture how a company actually handles refunds, pricing exceptions, incidents, approvals, and edge cases.
EvidenceYC's Company Brain RFS says domain knowledge is now the blocker to AI automation inside companies. YC RFS
Already outEnterprise search, knowledge bases, and chat-over-docs products answer questions. They rarely produce a living skills file that agents can safely execute.
Why nowModels are good enough to operate workflows, but they need current company-specific procedure maps.
Start herePick one workflow, such as refunds or incident response. Mine Slack, tickets, docs, and past decisions into a versioned procedure graph an agent can follow.
weekend build
YC RFS
Agent infrastructure / interfaces
Human SaaS needs an agent interface layer
Agents are forced to click through software built for humans. The wedge is an agent-readable layer: API, MCP server, CLI, docs, and auth flow for one popular workflow.
SignalYC RFS
PainBrowser automation is brittle: buttons move, forms change, sessions expire, and agents waste tokens reading screens instead of doing work.
EvidenceYC's Software for Agents RFS argues agents need machine-readable interfaces like APIs, MCPs, CLIs, and thorough documentation. YC RFS
Already outMost SaaS products expose human-first UIs plus uneven APIs. MCP coverage is early and fragmented.
Why nowCompanies are deploying agents before the software stack is ready for them.
Start hereChoose one painful SaaS workflow and ship an agent adapter with auth, docs, examples, and deterministic test tasks.
startup-scale
YC RFS
Product design / adaptive software
Users will expect software they can reshape
Most software still ships one interface for everyone. Coding agents make it plausible for users to reshape the interface around their own workflow.
SignalYC RFS
PainA student, founder, operator, and analyst may use the same email or CRM product completely differently, but the UI mostly stays fixed.
EvidenceYC's Dynamic Software Interfaces RFS argues coding agents may let users become their own forward-deployed engineers. YC RFS
Already outDashboards, views, and no-code builders customize around the edges. They rarely let users safely rewrite the interface itself.
Why nowCoding agents can generate and modify UI faster than product teams can build every niche workflow by hand.
Start hereBuild a narrow app where users can describe a workflow and generate a persistent custom interface over shared primitives.
startup-scale
YC RFS
AI-native services / operations
Do not sell the tool. Sell the completed workflow.
Many AI products still sell copilots. The bigger opportunity is replacing outsourced services by doing the work end to end.
SignalYC RFS
PainCustomers do not want another dashboard for compliance, accounting, admin, or insurance ops. They want the task finished correctly.
EvidenceYC's AI-Native Service Companies RFS points out that services spend is much larger than software spend and already outsourced in many categories. YC RFS
Already outMost tools assist the human operator. Few take responsibility for the service outcome.
Why nowModels can handle more complex knowledge work, and buyers are open to automation that owns a result.
Start herePick one recurring back-office service with clear inputs and outputs. Sell a done-for-you outcome, then automate the delivery behind the scenes.
startup-scale
YC RFS + research-to-product
Research-to-product / science
Scientific discovery needs closed-loop agents
Research copilots help scientists think. Discovery engines should help propose, test, interpret, and iterate hypotheses across the full loop.
SignalYC RFS + research-to-product
PainHypothesis generation, experiment design, analysis, and next-step planning are still stitched together manually in many scientific workflows.
EvidenceYC's AI-Native Discovery Engines RFS says the frontier is shifting from copilot research assistants to closed discovery loops. YC RFS
Already outLab copilots and literature tools improve pieces of the process, but few own the design-make-test-analyze loop.
Why nowFrontier models can reason over science, and automated labs/data pipelines can feed results back into the next iteration.
Start hereStart in one narrow domain with structured experiments. Build an agent that proposes the next experiment from prior results and explains its expected information gain.
weekend build
YC RFS
Agent infra / performance
Agent loops need a workload profiler
Before someone builds new chips for agent workflows, builders need to see where their agent runs actually spend time and money.
SignalYC RFS
PainAgent runs bounce between model calls, tool I/O, memory, browser actions, and orchestration. Most teams only see a blended latency and token bill.
EvidenceYC's Inference Chips for Agent Workflows RFS argues agent workloads are bursty, branchy, and poorly matched to simple prompt-in/response-out assumptions. YC RFS
Already outLLM observability tools track traces and cost, but fewer explain agent execution as a hardware/runtime workload.
Why nowAs agent runs get longer, every wasted context switch, idle tool wait, and repeated retrieval becomes real cost.
Start hereBuild a trace profiler that breaks one agent run into model, tool, memory, browser, queue, and idle time, then recommends the cheapest bottleneck fix.
startup-scale
YC RFS
Company OS / execution
Companies need a closed-loop operating layer
The next internal AI layer will not be another dashboard. It will watch the company's artifacts, compare plan to reality, and turn context into executable specs.
SignalYC RFS
PainImportant work lives across meetings, tickets, PRs, docs, support logs, and customer calls. Leaders only notice drift after it has already cost time.
EvidenceYC's AI Operating System for Companies RFS describes companies becoming queryable and self-improving through their own artifacts. YC RFS
Already outBI dashboards show metrics. Project tools show tasks. Neither turns company context into a live execution loop agents can act on.
Why nowAgents can read the artifacts and draft specs, but they need an integration layer that makes the company legible.
Start hereConnect Linear, GitHub, Slack, and meeting notes for one team. Flag when shipped work diverges from stated goals and draft the next corrective spec.
No opportunities match this filter.