The End of Apps

As a child, Kitze was already making checkbox lists. An old notebook contains barely legible reminders about everyday concerns: eat the string cheese. The tools became more sophisticated, but the underlying problem stayed recognizable: how do you get an intention out of your head and have it return when you can act on it?

Dissatisfied with Todoist and other to-do apps, he moved to text files roughly fifteen years before this talk. Android’s Tasker supplied the behavior around those files. Connecting to Wi-Fi, arriving somewhere, or biking could trigger a reminder. The file stored the intention; the surrounding automation decided when to surface it.

Voice capture removed another step. In his historical Google Home setup, IFTTT could recognize a command prefix such as “Tell my assistant to” and pass the remaining spoken text to a service. A task noticed around the house could become a stored record without opening an app. This was straightforward automation, not AI: its value was making capture easy enough to happen.

The accumulating experiments clarified the goal: a life OS, not another to-do list. Around 2016–2017, Tododo added a priority system. Tags such as health or crisis contributed points, and tasks accumulated those points to rise toward the top. Better expanded the scope to tasks, habits, and planner events—three kinds of information he wanted together. Its generic name also made search visibility difficult and eventually required a rebrand.

In 2022 he began Benji, named after his dog, who became its mascot and logo. The ambition grew into one app for everything. The expanding feature list covered routines, health, travel, finances, journaling, groceries, recipes, and more. Each impulse to market the product became an excuse to add another feature; years later, he still considered it unfinished.

Consolidation addressed real fragmentation: one service worked on the web, another on iOS, another on Android, with subscriptions and freemium limits scattered across them. Benji was supposed to pull those capabilities together. It had not fixed his life. His ambition for a Benji phone and operating system was grand enough that a podcast host pointed out the mismatch with his then-missing landing page.

Even a comprehensive system still demanded forms. Whether the container was Notion or Benji, someone had to enter the data. Kitze describes a cycle of logging everything for a month, then ignoring tasks, nutrition, and the whole system for months before returning. Consolidating applications did not remove the effort of maintaining them.

ChatGPT plugins suggested that a conversational interface could absorb work previously distributed across apps. Kitze called his wife to announce that apps and SaaS were finished—and that years of building Benji might have been wasted. Repeated announcements of imminent transformation eventually made these calls a household joke. Plugins and the later Model Context Protocol belong to that broader tool-connection story, but MCP was a separate protocol introduced by Anthropic in November 2024, not a renamed version of ChatGPT plugins.

His early integration in 2023 still required coaxing usable JSON out of model responses. Instructions to omit Markdown could produce a helpful preamble followed by JSON, forcing extra parsing and cleanup. That describes the integration he was building, rather than all of 2023: OpenAI introduced JSON mode that November for GPT-4 Turbo and the updated GPT-3.5 Turbo, providing syntactically valid JSON rather than guaranteeing the correctness of every field.

The Benji prototype connected speech to visible application changes:

1. A keyboard shortcut activated microphone capture.
2. While he spoke, the system periodically cut off a portion of the speech for processing.
3. The integration called Benji APIs.
4. Calendar entries and to-dos changed live in the interface.

No MCP was involved. The important transition was from recording a thought to changing structured application state without completing a form.

The demonstration attracted enthusiastic attention on Twitter, but the assistant remained unshipped at the time of the talk. Kitze contrasts Benji’s sixty features with his account of focused photo-based calorie trackers making millions. The uncomfortable product lesson is that expanding scope and demonstrating a compelling interaction are different from delivering a focused product people can use.

By the previous October, Claude Code’s tool calls and functions suggested uses beyond programming: organizing email, managing tasks, perhaps even helping with taxes. Kitze began adding personal skills alongside coding skills, then found the mixture confusing in his setup. He wanted an assistant built on those capabilities, with tools and context appropriate to personal work.

The terminal was the wrong interface for that relationship. Peter’s Clawdbot, the project later known as OpenClaw, made the assistant reachable through WhatsApp or Telegram. That change made the existing coding-agent capabilities feel usable in everyday life. Kitze joined its Discord early, when he recalls fewer than one hundred people having working setups and onboarding was still missing.

He did not become an expert in its internals. Instead, Codex or Claude Code configured and repaired the installation, changed behavior, and adjusted memory. When people asked what was in his JSON configuration, his answer was effectively that the bots handled it. The assistant’s setup was itself becoming work delegated to another agent.

The enthusiasm extended beyond configuration: a lobster suit at the first Vienna meetup, merchandise, tutorials, podcasts, and, in Kitze’s account, creating the OpenClaw logo at two in the morning. The attraction underneath that enthusiasm was access to a long-standing backlog: Google Drive and iCloud files, presentations, high-school photos, and unfinished business ideas. An assistant finally seemed capable of working across it.

Control over files, memory, and session deletion changed what he wanted from his infrastructure. The setup felt local and owned, although ownership of those components does not establish that model inference was also local. He began moving data toward a NAS or his own machine, using Nextcloud, Immich, and local Markdown. These migrations remained works in progress. His preference was direct access to local data instead of repeatedly crossing API or MCP boundaries.

The same motivation took him back to Android. He wanted an agent to read and clear notifications and install or remove apps. Compared with the restricted access he associated with iOS, Android offered the device control he was seeking. The choice of phone followed the desired assistant capabilities, rather than the assistant being confined to whichever phone he already preferred.

A useful question at weekly Tinkerer Club meetings was which OpenClaw use cases actually required OpenClaw. Kitze estimates that the proposed exclusive use cases shrank by 90% when people considered whether Claude Code or Codex could do the same work. This was an informal discussion, without a measured task inventory. It shifted the question from raw capability to the value of packaging an assistant.

One conversation with one agent had its own limits. Imagine hiring a single employee and loading them with every detail of your business, family, and personal life, then discussing everything in one Telegram chat. Telegram topics, Discord, and Slack offered ways to separate those conversations. Specialized agents offered a more explicit division of responsibility.

A fitness agent, for example, could bundle several independent choices:

• Inference: provider, model, and thinking level.
• Role: a system prompt or “soul” defining its purpose.
• Capabilities: tools and MCP connections.
• Authority: permissions governing what it may do.

That package gives a conversation a narrower purpose than a general assistant carrying everything.

Kitze created bots for different parts of work and life, then accumulated five Discords with channels, threads, forum posts, and nested organization. He describes the resulting system as more chaotic, not more productive: rent, mortgage payments, and customer emails were later than ever. Separating responsibilities had produced a new coordination burden.

The community’s initial excitement also faded. Kitze recalls meetings dwindling to about five people, with conversation increasingly resembling “OpenClaw anonymous”: people comparing what their setups had failed to do. His failures clustered around the features a persistent assistant most needs—cron jobs, coordination among agents, communication between them, and remembering context from the immediately preceding message. Updates arrived daily, but he had not yet seen dependable operation in his own setup.

A separate problem belonged to the interface. Discord and Telegram were designed for messaging, not managing an entire life. Kitze does not blame OpenClaw for that mismatch; the messaging products were being pressed into service until something more suitable existed.

He also associates an unspecified Anthropic model-access change with a loss of the assistant’s charm, and describes GPT-5 as having the personality of a box of oats. But the more consequential complaint is behavioral: ask whether something was done, hear that it was not, repeat the instruction, then discover it still has not happened. A conversational commitment is not evidence of execution.

Two directions emerge: custom assistants such as OpenClaw and Hermes, and cloud offerings such as Claude Cowork, an anticipated OpenAI offering, and Perplexity’s efforts. Kitze doubts either direction, as he currently experiences it, satisfies both ordinary users and committed tinkerers.

Even Tinkerer Club members who build their own pinball machines were tired of maintaining agents. People with less interest in tinkering want something that works out of the box. Yet after about five minutes with Cowork, Kitze judged it capable of less than 5% of what OpenClaw could do. That was his initial impression, not a capability benchmark.

Convenience may suit mainstream users while still leaving people who want to self-host and control their models dissatisfied.

His own daily rotation includes OpenClaw, Hermes, Paperclip, and plain tmux with Codex. He describes Paperclip as a Kanban or Linear-like interface for agents that consumes plenty of credits. When the agent frameworks become frustrating, the terminal can feel reassuringly direct.

The trust barrier appears even in a simple task: finding the conference venue. He could open the website, or ask the agent through Discord to find the address in his email. Anticipating another promise followed by an unnecessary “Are you ready for it?” made the direct lookup more appealing. Delegation loses its advantage when supervising the assistant feels harder than doing the task.

The next experiment is Wolfer, a small abstraction over a coding agent, built for Kitze rather than a mass audience. At the time of the talk it uses Codex only. It does not aim to support a broad range of providers or extensions.

Its limitations are deliberate and substantial. Users must use Wolfer’s own chat UI; there is no Telegram or iMessage integration. Functionality is intended to live inside the application rather than in plugins. There is no memory system, modularity is limited, and Kitze is uncertain whether he will keep developing it or release it publicly. It also lacks OpenAI funding and a lobster logo. What he wants in return is predictable conversation behavior.

Wolfer’s interface is organized around multiple agents, topics, and conversations from the outset. Its most distinctive mechanism is explicit context assembly. Instead of depending on a memory system to retrieve the right background, Kitze organizes topics into a hierarchy. His example is work → projects → Benji → Benji customer support.

When a conversation starts in Benji customer support, the first prompt receives the descriptions of that topic and all its parents. The procedure is direct:

1. Locate the current topic.
2. Walk through its parent topics.
3. Collect their descriptions.
4. Combine those descriptions into the initial prompt.

The support conversation therefore receives context about his work, his projects, Benji, and the support process. The following TypeScript expresses that assembly using the same topic path; the short descriptions are teaching values.

type Topic = {
  id: string;
  description: string;
  parentId: string | null;
};

const topics = new Map<string, Topic>([
  ["work", {
    id: "work",
    description: "Work: help Kitze manage his work.",
    parentId: null,
  }],
  ["projects", {
    id: "projects",
    description: "Projects: organize work by product.",
    parentId: "work",
  }],
  ["benji", {
    id: "benji",
    description: "Benji: a personal operating system.",
    parentId: "projects",
  }],
  ["benji-customer-support", {
    id: "benji-customer-support",
    description: "Support: draft replies to Benji customers.",
    parentId: "benji",
  }],
]);

function initialPrompt(topicId: string, request: string): string {
  const descriptions: string[] = [];
  const visited = new Set<string>();
  let currentId: string | null = topicId;

  while (currentId !== null) {
    if (visited.has(currentId)) throw new Error("Topic cycle");
    visited.add(currentId);
    const topic = topics.get(currentId);
    if (!topic) throw new Error(`Unknown topic: ${currentId}`);
    descriptions.unshift(topic.description);
    currentId = topic.parentId;
  }

  return [...descriptions, `Request: ${request}`].join("\n\n");
}

const prompt = initialPrompt(
  "benji-customer-support",
  "Draft a reply asking which device the customer uses.",
);

The result is a prompt, not a sent customer reply. The useful property is inspectability: the topic path determines which standing descriptions enter the conversation. Kitze reports that this works better for him than hoping a memory system retrieves the right context.

The remaining Wolfer features address the difficulty of understanding what an assistant is doing. Workspaces can be switched. Tool calls can be expanded or collapsed, loading indicators show activity, and a stop button replaces the need to remember a slash command. Kitze describes cron messages as reading the entire conversation and carrying an explicit cron label, so scheduled activity has both context and a visible origin.

An agent-management panel sits beside the topic. It shows the active agent—Chandler in his example—along with its model and capabilities. Removing a capability makes it disappear from that configuration. These are speaker-described behaviors: the application was running on his Mac Studio at home and was unavailable for the presentation, so he could not show application screenshots.

Task-specific context has a separate path into the conversation. Wolfer includes a knowledge base and editable Markdown documents, with dynamic @ mentions extending beyond the member mentions he uses in Discord. For example, he can ask to improve Benji’s landing page and mention the Tinkerer Club landing page as a reference. Multiple mentions can combine a knowledge base, a password, or a skill. The topic tree supplies standing background; selected objects supply the exact material needed for the current task.

Wolfer is a personal experiment, not Kitze’s proposed mainstream destination. His broader forecast starts with a familiar computer experience: returning after a few hours to seventeen app updates and yesterday’s open tabs. The machine presents the state of its applications rather than the work that now matters.

He imagines a system that ingests notifications, email, to-dos, and other information about his life. Depending on how long he has been away, it would greet him with the next task, sequence what follows, and suggest a break when appropriate. The computer would help manage attention instead of merely preserving open windows.

Kitze forecasts highly productive users delegating 99% of their work to AI, with the AI then prompting them for decisions and missing inputs. This is an aspiration, not a measured productivity result. A background process might ask for a passport photo, present a form, or request a choice. The human still supplies judgment and information, but no longer has to initiate every piece of work.

Ordinary users do not need to become programmers for this forecast to work. They would describe a task to the operating system and receive whatever interface the task requires, potentially generated on demand. The habit of first finding an app could recede. Specialist software would remain for work such as color grading, filmmaking, and music creation, where dedicated tools are part of the practice.

Kitze then proposes a possible winner: Apple. If local models become capable enough, a Siri-like agent could obtain tools from installed applications and carry out everyday tasks without per-request credit spending or sending the user’s data elsewhere. That is his proposed local-agent architecture, not a description of an already available end-to-end system.

He closes with a nearer-term example: Pixel phones performing background app tasks, including ordering coffee. Google’s March 2026 Pixel announcement supports coffee reordering as a beta capability rolling out over several weeks. Its task-automation announcement limits the initial offering to selected devices, regions, and apps, with monitoring and interruption controls; the illustrated order still asks the user to complete it. This points toward agents operating applications on a user’s behalf, without establishing the fully local future Kitze imagines. The apps may remain underneath, while the user’s interaction begins with the task.