talktag

The idea

Imagine the model is a person. When a person thinks, most of it stays inside their head. When they want to say something to you, they consciously open their mouth and say it. The internal beats — “hmm,” “wait, what did they actually mean,” “okay let me try this” — never leave their skull. They're not lies. They're just not for you.

LLMs don't work that way today. Every token they emit is assumed to be addressed to you, which is why they over-explain, hedge in the open, and narrate the obvious. Talktag changes the default: tokens are private until the model decides to speak.

How it works

The model is given one new instruction in the system prompt: anything it wants the user to read or hear must be wrapped in<talk>...</talk>. Everything else is automatically classified as inner monologue. A small streaming parser sits between the model and the UI; as tokens arrive, the parser routes each one to either the public reply lane or the inner-thoughts lane based on whether it sits inside an open talk tag.

The renderer surfaces both — but very differently. The public reply is what you see in the chat bubble, and what gets sent to text-to-speech. The inner monologue is rendered alongside as soft, ambient text — the way a person's thoughts would feel if you could see them: present, unedited, not for you, but real.

Heartbeat mode

Once speech is opt-in, you can run the model as a long-lived loop instead of a one-shot reply. In heartbeat mode the model wakes up on a tick, checks whatever it's been asked to watch (inbox, build status, on-call queue), thinks through what it found, and only emits a <talk>block if something actually needs your attention. Most ticks produce nothing but inner monologue and quietly go back to sleep — the model is on duty without being chatty.

Try the “heartbeat” tab in the demo above: the model polls an inbox every 60 seconds, ignores newsletters and routine calendar reminders, and only opens its mouth when a real high-priority message lands.

What it changes

• Honest pauses.“Hmm, let me think about that” stops being filler and starts being a real beat — because the model isn't pretending it's for you.
• Less performative reasoning. Chain-of-thought today leaks into the user-facing reply. With talktag, the chain stays where it belongs (in the head), and the reply is what actually got said.
• Real silence.The model can think for a while, decide it doesn't need to say anything yet, and just emit nothing into the talk lane. The user sees thinking happening; the chat bubble stays empty until the model has something it actually wants to say.

vs. OpenClaw thinking levels

OpenClaw is a personal-AI-agent gateway that supports a thinking level directive — you set /think:medium on a session and the agent appends a Reasoning: block to its replies. It's a useful debugging knob, but it's the inverse of what talktag is doing — and the polarity matters.

• Default polarity.OpenClaw's reasoning is opt-in: you turn it on when you want to see it, off when you don't. Talktag flips that — every token is private by default and the model has to opt in to speaking. That's not a UI preference; it changes how the model decides what's worth saying.
• One stream, not two messages. OpenClaw ships reasoning as a separate Reasoning: prefix attached to a reply — still inside the question/answer loop. Talktag is one continuous stream where thinking and speaking interleave inline; the model can think, call a tool, think again, then speak, all in a single uninterrupted run.
• Heartbeat / always-on mode.OpenClaw is still fundamentally request/response — you message it, it replies. Talktag's opt-in speech enables a model to run as a long-lived loop that mostly stays silent and only surfaces a <talk>when something crosses a threshold. That mode doesn't exist in the OpenClaw shape because every turn is expected to produce a reply.
• TTS-honest. Pipe the stream to text-to-speech and only <talk> gets voiced — the model can think for a long time without the speaker reading its scratchpad aloud. With OpenClaw you'd have to filter the Reasoning: prefix out of the audio path manually.
• Works with non-CoT models.Models that don't expose a chain-of-thought channel can still think out loud under talktag — the “thinking” is just regular generation that happens to live outside talk tags. OpenClaw's reasoning level depends on the underlying model exposing a reasoning block.