Summary

Tasklet’s core bet is that model-led agents will overtake deterministic workflows because agents can route around the real-world exceptions that break flowcharts. Andrew Lee concedes that today’s models are “probably” somewhat less reliable for many business applications, but predicts that gap disappears within six months and eventually reverses: “Rather than having software wrapping LLMs, you have LLMs wrapping software.”
The product is evolving from recurring automation into a persistent, language-native virtual employee. A high-level agent retains responsibilities and feedback while sub-agents execute individual runs; users can also return for ad hoc work, and most messages already fall into that category even though nearly every paying user has an automation. Some customers name agents, give them dedicated email accounts, and treat them as colleagues: “This is Joe, my EA.”
Lee still selects models “on vibes,” with Anthropic decisively preferred for long tool-using sequences despite GPT-5’s stronger published task-length result and lower price. His claim is not that Sonnet always gives the best first answer, but that small advantages compound across 100 iterations; the fact that GPT-5 costs less than half as much without triggering broad switching is his market-based evidence that “the real-world utility” of Sonnet is higher.
Tasklet’s distribution wedge is universal connectivity rather than a curated handful of integrations. It combines 3,000-plus integrations and business tools, arbitrary APIs, MCP servers, and computer use; one paying customer even replaced Notion’s official MCP with Tasklet’s model-generated direct API connection because it worked better. Lee’s emerging MCP view is blunt: if tools merely mirror documented endpoints and models can discover those endpoints themselves, “what’s the point of MCP?”
Long-lived agents make context engineering and compute infrastructure—not the basic agent loop—the consequential technical work. Tasklet replaced an always-present mutable JSON memory that became unwieldy after a week or two with an agent-managed SQL database, while pursuing compaction, selective retrieval, and eventual “uncompacting” of old history. The north star is an economically impossible but experientially valuable illusion: “one big long chat” in which everything remains available and intelligently considered.
The economics are early-stage and unfavorable, but Lee sees familiar cost curves and a near-term Haiku 4.5 lever. Shortwave progressed from launches that might have bankrupted the company to healthy, though sub-90%, margins; Tasklet is currently “strongly margin negative,” consumes far more tokens, and must police zombie automations among free users. Haiku 4.5 costs roughly one-third as much as Sonnet, potentially allowing much larger quotas without equivalent margin damage.
The strategic endgame is a trusted horizontal agent platform, but Lee believes speed is the only present moat. He expects general-purpose models and generated interfaces to eliminate much vertical SaaS—eventually even Shortwave in its current form—while direct APIs and computer use erase connector libraries accumulated over years. Tasklet’s launch was adding revenue much faster per unit time than Shortwave ever had, yet the durable enterprise opportunity depends on becoming “the most trusted way” to deploy agents, with permissions, auditability, compliance, and potentially insurance.

Deep dive

1. Tasklet emerged when Shortwave users asked their agents to work unattended

Nathan Labenz described Tasklet as blurring the line between a chatbot and a structured workflow or agent, and said he had tested it for roughly a month.
Lee traces the idea to Shortwave’s MCP integrations: customers moved information from email into Notion, Asana, and HubSpot, then asked why the same prompt could not run automatically before they woke up each morning.
Once the agent worked while nobody was at a computer, tight coupling to an email interface stopped making sense. The team broadened the project into general-purpose automation, writing code from roughly June until the launch shortly before the conversation.

2. Putting the model above the workflow changes the reliability ceiling

Traditional products such as Zapier, n8n, and OpenAI’s AgentKit put conventional software in control: users specify step one through step four, with occasional LLM calls inside the boxes. Lee thinks that was appropriate “a year or two ago when models were smart but not that smart.”
Tasklet inverts the stack. “Rather than having software wrapping LLMs, you have LLMs wrapping software”: the model plans and makes the large decisions, while ordinary code executes tools and can enforce constraints such as inferred type restrictions.
Labenz’s pushback — worth keeping: structured workflows appear costly to build but more dependable once configured. Lee’s answer is that their upper reliability bound remains limited because an unanticipated error simply breaks the flow, whereas an agent can interpret the situation, handle nuance, and find another route.
Lee does concede the present tense: for most business applications, today’s agentic solution is “probably” somewhat less reliable. His categorical forecast is that this changes quickly—“I give you six months”—and that model-led systems eventually become both easier and more reliable in essentially every scenario.

3. A persistent boss agent delegates runs to bounded sub-agents

Tasklet’s high-level agent maintains the continuing relationship, responsibilities, and instructions; triggers then spawn sub-agents for individual executions. Those runs have bounded permissions and their own trace, giving users a place to inspect exactly what happened.
Lee groups the surrounding product work into three areas: connections to heterogeneous internet services, triggers that launch encapsulated runs automatically, and organizational collaboration. The last category is nascent but is intended to cover sharing, oversight, auditing, and cost controls for core business processes.
Model control does not preclude hard guardrails. Tasklet already asks the LLM to infer types for dynamically constructed connections and enforces those types in code; Lee imagines agents eventually generating their own flow constraints when a particular phase truly must follow prescribed steps.

4. Model selection remains vibes-based because customers demand the frontier immediately

Asked whether his evaluation philosophy had matured, Lee answered, “Still running on vibes.” Tasklet is changing too quickly for an evaluation regime that constrains releases, and customers pressure the company to deploy each new Anthropic model almost immediately.
The team can swap models and hand-test different use cases. Lee finds that OpenAI models may equal or outperform Anthropic on one-question, one-answer tasks, but Anthropic handles repeated “LLM call, tool call” cycles better; a small per-turn advantage becomes material across 100 iterations.
Labenz pressed him on METR’s task-length estimate, where Sonnet 4.5 landed below GPT-5 while still following the broader curve at roughly the two-hour level. Lee’s honest non-answer: “I don’t know why that difference is there,” followed by the cynical possibility that some people play harder to hack published metrics than others.
His alternative signal is price discovery: if GPT-5 were as useful for these workflows while costing less than half as much, users should be switching aggressively. They are not, and Anthropic maintained Sonnet 4.5’s pricing despite OpenAI’s reductions—evidence, in Lee’s view, that buyers prefer its real-world utility.

5. Turn count, not human-equivalent time, defines Tasklet’s current frontier

Tasklet does not translate work into the hours a human would need; the small team measures turns because turns correlate directly with cost. Lee leaves human-time comparisons to researchers: “We’re just trying to build a thing that people will pay for.”
A 50-turn limit was originally an emergency brake against bugs generating infinite bills, but users now hit it routinely. Computer use is the main culprit: finding 10 people on LinkedIn and messaging them can require at least one, and sometimes several, model turns per interface operation.
Sonnet 4.5’s computer use felt “super impressive,” yet intelligence was no longer the chief bottleneck; screenshot-driven navigation is slow and tremendously expensive. Tasklet considered a cheaper Gemini sub-agent, but distilling its result back into the main agent lost intelligence, while Haiku 4.5 was too newly deployed for Lee to judge.

6. The agent computer must feel dedicated without being paid for while idle

Each agent currently receives a SQL database, code execution, limited file capabilities, and an optional full Linux VM with a browser and filesystem. Tasklet dropped Windows because it was expensive, woke slowly from sleep, and rarely provided value beyond what users did in a browser.
The roadmap is to connect the shell, filesystem, database, code runtime, integrations, and graphical interface into one coherent computer. Lee’s deliberately mundane example: users ask agents to convert video formats, something a terminal-equipped agent could accomplish immediately with FFmpeg.
The desired illusion includes preserving state across suspension without letting an agent corrupt permanent configuration. The infrastructure puzzle is avoiding 100 continuously provisioned machines or 100 copies of an operating system; Lee called the requirements uncharted and mentioned Blaxel in this specialized cloud layer.

7. Recurring jobs are the wedge, but persistent ad hoc work drives engagement

The first Tasklet separated setup from execution and stopped users from talking to an agent once its automation ran. Customers objected: after configuring email triage, Notion, Asana, and detailed preferences, they did not want to recreate everything merely to ask that knowledgeable agent to draft one email.
Letting the same agent handle triggers and conversation changed the product model. Users began naming agents—“This is Joe, my EA”—and Lee started imagining heavyweight relationships that might last years, unlike the disposable conversation list accumulated in ChatGPT or Claude.
The usage mix supports that reframing: essentially every paid customer has an automated recurring task, yet most messages are ad hoc requests to those same configured agents. Reported workflows include billing operations, executive-assistant work, music-venue calendars and stakeholder updates, and a commodities trader monitoring real-world events to recommend trades.
Lee said he uses the product heavily for marketing and that content from Shortwave or Tasklet was written through “Lindy”; he described an agent that reads his notes and spreadsheets, then produces a LinkedIn post or podcast spot on demand. Labenz likewise used his agents for research, prospective Detroit podcast guests, and gaps in his interview outline.

8. High-level feedback turns execution traces into employee coaching

Labenz’s paper-finding agent inferred his interests by reading The Cognitive Revolution website, then embedded that understanding into future runs. When he noticed repeated papers, he told the high-level agent to consult its stored history first; it updated the standing procedure without requiring him to rewrite the workflow.
That interaction produced the “virtual employee” feeling: review completed work, identify a recurring weakness, and let the worker translate broad feedback into future operating practice. The value lies precisely in avoiding step-by-step reprogramming.
Tasklet previously made run-level conversations easier, but users faced “20 places” to talk to the AI and rarely used them. Lee now wants one conversation with the main agent, backed by an introspection system that gives it enough knowledge and control to continue, inspect, or redirect recent sub-agent runs.

9. Just-in-time instructions may eliminate an entire source of prompt conflict

Tasklet once persisted intermediate sub-agent instructions and let users edit them directly. That created ambiguity between what a user had told the main agent, what the main agent generated, and what the user later changed manually—even when the user explained the edit.
Lee is considering moving away from pre-generated instructions. A separate process could assemble them just in time and out of band from all relevant information, avoiding the slow, error-prone requirement that the main agent both complete an immediate request and decide whether its standing prompt needs revision.
Users would retain control through language: ask the agent to summarize its current understanding, correct that summary, and specify anything that must be followed exactly. Lee believes this preserves specificity and inspectability without creating competing sources of truth in the interface.
Prompt coherence receives unusual executive attention. Lee personally reviews every pull request that touches the main prompt, despite not normally acting as CTO or code reviewer, because individually reasonable additions conflict “a surprisingly large amount of the time” when the full instruction hierarchy is considered.

10. Context engineering is the core illusion behind a years-long relationship

Labenz raised the finite 200,000-token budget: an agent that processes 100,000 emails and revisits runs from different dates cannot literally keep everything present. Lee embraced “context engineering” as a better description than the overloaded term RAG for the systems that plumb the right information into a model.
The target experience is that everything ever said, processed, or learned is considered continuously, while the implementation does nothing of the kind. “You have to give the illusion to the user” that both the history and the model’s ability to reason over it are effectively unlimited.
Tasklet can hide old tool outputs, summarize large spans with model-based compaction, and give sub-agents tailored subsets instead of the full conversation. Future tooling could retrieve a specific historical run only when needed, keeping normal execution small while preserving apparent continuity.

11. SQL replaced mutable prompt memory because models already know how to operate it

Tasklet’s first cross-run memory was intentionally primitive: a JSON object lived in the system prompt and sub-agents edited it through tool calls. “This was like the dumbest thing we could think of,” Lee said, yet it worked surprisingly well because the information was always visible.
The failure arrived after a week or two: objects grew large enough to degrade performance, and changing mutable state inside the system prompt repeatedly destroyed cache reuse. The design’s retrieval-free convenience could not offset its scaling and economic problems.
The replacement is a dedicated SQL database per agent. Models are “super good at writing and using SQL,” so an agent can store state, retrieve subsets, and maintain instructions for how that state should evolve without Tasklet imposing one universal memory schema.
Lee is explicit that SQL is not the endpoint: agents can still naïvely load an ever-growing table. Tasklet may add tools that “uncompact” selected old conversations. Lee says the company is not using other memory providers because it views this as a core problem; he had not yet tried Anthropic’s latest memory features and thought its context-editing approach could be built in-house.

12. Tasklet favors better model reasoning over building a universal knowledge graph

Labenz proposed a HippoRAG-style process that periodically connects stored facts into a graph, improving later retrieval through neighboring nodes. Lee suspects something like that might work but rejects it as the right business investment for Tasklet.
Internal memory is only one information source; an agent must also search Gmail, Salesforce, Notion, and many other systems whose datasets are too large for Tasklet to ingest universally. Perfecting an internal graph would therefore improve only a fraction of the overall retrieval problem.
Shortwave demonstrates the trade-off: with the same frontier model, its custom semantic email search beats Tasklet’s use of ordinary service search, but the stack is enormously complex and expensive. Tasklet instead bets models will improve at legacy search and services such as Gmail might eventually expose good semantic-search APIs themselves.

13. Direct API discovery turned 10 planned integrations into universal connectivity

The team expected to handcraft roughly 10 priority integrations, as it had for Shortwave. A Pipedream connection unexpectedly made a much larger catalog work with little custom prompting, followed by similarly successful MCP support.
The pivotal experiment was arbitrary HTTP: Tasklet searches the web for an API’s documentation, extracts a usable description, and lets the model formulate constrained calls. It worked “shockingly well”; one paying customer abandoned Notion’s official MCP for Tasklet’s fully model-generated direct API connection because it was more reliable.
The resulting stack combines Tasklet-built integrations, integration platforms, provider MCP servers, user-supplied MCPs, arbitrary APIs, and computer use behind one configuration and permissions interface. The strategic message is intentionally absolute: “We work with everything. There’s nothing we can’t connect to.”
Computer use closes the final gap when no API exists—or when a provider such as LinkedIn does not want automation. Tasklet still hand-optimizes the most important connectors, but the model and browser prevent the long tail from becoming a years-long connector-building exercise.

14. Connections are reusable credentials, while authority remains agent-specific

A connection is an authenticated, stateful link to an external service. Initial setup may use OAuth or require an API key, server details, and custom headers; once created, it belongs to the user and can be reused rather than reconstructed for every agent.
Reuse does not mean blanket access. Each agent must receive its own explicit tools and permissions, following Lee’s employee analogy: a company would not give every human worker access to every system, so it should not do so for virtual workers either.
The enterprise roadmap moves connections to a team layer where IT can establish approved credentials, assign access, monitor audit logs and costs, and enforce policies. Employees would then build agents from vetted connections instead of attaching arbitrary AI products to company systems however they please.

15. MCP remains useful for authentication, but its tool layer looks vulnerable

Lee began the year “extremely bullish” on MCP: community growth was rapid, it solved an obvious connectivity gap, and it inspired Tasklet itself. Claude 4 forced the team to revisit that conviction because models had become capable of discovering and calling documented APIs end to end.
His central challenge is conditional: if MCP tool definitions merely mirror public API calls, “what’s the point of MCP?” A model can scrape the documentation, derive its own descriptions, and invoke the endpoints directly without depending on a provider’s tool design.
Authentication remains a genuine advantage. Tasklet at one point used Notion’s MCP authorization to obtain workspace-wide access while overriding Notion’s tool definitions with its own; today it exposes MCP, direct API, and integration-platform options and lets users choose.
Labenz proposed “smart MCPs” that express intent and encapsulate multi-call operations. Lee accepts the Gmail example—forwarding really means constructing and sending a correctly formatted new message—but thinks models may eventually generate these logical groupings, making hand-maintained high-level MCPs vulnerable too.

16. Lunch ordering exposes why human approval is harder than it sounds

Daily DoorDash ordering was Tasklet’s canonical internal automation because it combines attendance, dietary preferences, guests, restaurant variety, cancellations, deadlines, and exceptions. Lee’s team has worked with human executive assistants on similar work and still sometimes forgets, illustrating why a simple lunch workflow becomes operationally messy.
Tasklet currently completes only half the job: it emails restaurant recommendations with DoorDash links, after which someone selects a restaurant and starts the group order. Lee believes computer use can close that gap, but approvals may still be needed for guests, participation, or the chosen restaurant.
Sub-agents can request input and email the user, but the feature is rarely used and “doesn’t work super well.” Lee wants exceptions escalated into the main agent, which can decide whether human help is necessary; doing that well probably requires a mobile app and push notification rather than another email.

17. Tasklet builds its agent stack itself—and increasingly uses Tasklet to test it

The short infrastructure endorsement list is Pipedream, Google Cloud, and Anthropic. Google Cloud backs the VMs; the agent implementation is in-house TypeScript rather than LangChain, with Sentry and Statsig elsewhere in the operating stack.
Coding work is heavy on Claude Code and Cursor, with Codex preferred by some engineers or used alongside Cursor. Lee suspects AI now drafts a majority of lines, though “writing the lines of code is often not the hard part” and does not represent a majority of the underlying reasoning.
Ticket-to-pull-request automation works when the architecture already supports a clean fix. Otherwise an agent may “hack in a solution” that passes locally while damaging the system; by contrast, Tasklet’s pricing, release-notes, and terms pages were essentially one-shot implementations from Claude Code.
Tasklet also tests itself: agents exercise integration tools, diagnose VM hibernation and remote-desktop configuration, and navigate the product UI. The most recursive demonstration opened Tasklet through computer use and edited the very agent operating it—a “hall of mirrors” that Lee found hilarious.

18. SOC 2 addresses company controls, not whether the agent behaves well

Lee stressed that Tasklet takes privacy seriously and plans to pursue SOC 2 soon after launch. He rejects the idea that it is mere theater: controls over employee access and customer data remain important, even though they do not govern agent behavior.
The missing standard concerns whether the agent itself will do the right thing. Security professionals have told Lee, in effect, “We have no idea; this is the Wild West,” but Tasklet had received no complaints about an agent going rogue despite abundant reports of ordinary bugs.
Lee attributes that early result partly to expectation-setting: agency is explicitly the product, while users choose connections and permissions. He expects scrutiny to rise with larger customers and higher-value work, making trust—not merely capability—the medium- and long-term basis of the company.

19. Insurance could become the confidence layer that agent deployment lacks

Labenz described the AIUC-1 standard from the AI Underwriting Company and the broader idea of pricing agent risk through insurance: force precise judgments about likelihood, severity, and controls by asking whether an insurer can profitably write the policy.
Lee found the concept appealing and invoked early Airbnb, whose insurance policy after a host’s home was damaged helped restore trust in a risky new marketplace. A substantial policy can be both compensation and a concrete signal that someone has assessed the underlying exposure.
His strategic conclusion is that many products will eventually automate work across many tools; Tasklet must distinguish itself as “the most trusted place” for enterprises to deploy those agents. Compliance, auditability, permissions, and insurance all support that position, even though the relevant agent-risk standards remain unsettled.

20. Tasklet is repeating Shortwave’s path from dangerous costs toward viable margins

Early Shortwave launches raised an existential question: “Will this bankrupt the company?” Usage was expensive but never bankruptcy-level, and monetization, lower model prices, caching, and optimization eventually produced healthy margins—though not traditional SaaS margins near 90%.
Tasklet resets the economics because nearly all value is AI-generated and each customer consumes many more tokens. Lee says it is currently “strongly margin negative,” managed through daily quota meters while the team expects the same long arc toward neutral, positive, and eventually strongly positive margins.
Haiku 4.5 is the immediate lever: unlike the long-stale prior Haiku, it is fast, capable enough for many tasks, and approximately one-third the price. Tasklet was adding it during the conversation so users could receive substantially more quota without equivalent cost growth.
Free recurring jobs create a zombie problem: some users may burn around a dollar per day while ignoring every output. Lee expects paid users to retain discretion, but inactive free accounts may receive a warning and then have automations disabled unless they return to the app.

21. Immutable histories and selective state placement drove an 85% cache hit rate

Lee’s caching rule is that the agent transcript should behave as an immutable log. Editing an earlier message invalidates everything after it, so prompts and histories should only append while different segments receive no cache, five-minute caching, or one-hour caching according to expected reuse.
Shortwave has pushed its cache-hit rate to roughly 85%. A major technique was moving mutable information out of the system prompt and into hidden system-message blocks appended alongside new user messages, preserving earlier cached prefixes.
Current time illustrates the trade-off: place it in the system prompt and every minute invalidates caching; omit it and the model lacks useful context; retrieve it through a tool and every answer pays for another turn. An appended hidden block supplies it cheaply without rewriting history.
The same pattern can carry user state and Shortwave memories, while compaction reduces old history. Tasklet’s abandoned mutable JSON memory violated this economic architecture, making the later move to SQL both a scaling improvement and a caching decision.

22. Longer-horizon intelligence favors one all-context agent over a swarm

Lee’s preferred progress metric is autonomous task length. Single responses already look uniformly smart, but a model that is even “0.01% better at every turn” can become radically more effective by turn 100 or 1,000; he expects that compounding frontier to advance for a long time.
Within one user’s application, he has not found a good reason to split responsibility among peer agents. One powerful model given all relevant tools and context consistently performs better; multi-agent structures make more sense when separate parties must preserve private information or negotiate adversarially.
Labenz proposed routing different work to marketing or HR agents and raised the idea of an independent quality-control supervisor. Lee’s answer remained the same: specialization mainly changes context and tools when the underlying foundation model is already expert across domains, and a separate reviewer has not yet improved results in Tasklet’s experiments.
Labenz’s extrapolation was deliberately aggressive: four-month doubling implies 8× longer tasks annually, moving from roughly two hours now to two days, two weeks, and then quarter-scale projects by 2028. Lee expects longer tasks, while treating blackmail-style research scenarios as heavily influenced by conflicting goals rather than a clear forecast of production behavior.

23. Horizontal agents threaten vertical SaaS, so speed remains the only moat

Lee expects foundation models that are “experts at everything” to power horizontal platforms capable of generating interfaces and processes for construction, medicine, or marketing on demand. Vertically integrated businesses can remain, but many intermediate vertical SaaS products may disappear.
Labenz summarized the interaction shift as “AI beats UI.” Lee applies it even to Shortwave: once a user can ask an agent to generate a fast-triage email client with specified constraints, Shortwave in its current form loses value—though he thinks that point is years, not quarters, away.
Tasklet’s nearer ambition is an employee that progresses from email triage and invoices toward running a small business’s entire marketing function. Lee avoided that phrase initially because “virtual employee” products routinely overpromise, but users naming agents and giving them email identities suggest the paradigm is already forming.
The launch was growing rapidly and adding revenue faster per unit time than Shortwave ever had, yet Lee found no moat beyond execution speed. Direct APIs erased years of connector accumulation; generated software will erode application moats next. The operating maxim is to discover the next capability before competitors reproduce the current one.

Why Creativity Will Matter More Than Code | Kevin Rose and Anish Acharya E210 | Japan’s “Lost 30 Years” Made China’s Most In-Demand Restaurant Chains?