DotSet

Every morning my scheduled agents in ChatGPT and Codex sent back their results as messages: two new papers, one on recent HCI and one on disability innovation, and a note on sterling against the yuan. Chat is built for a question and its answer. For things that arrive every day it fails in three ways. The text is long and hard to scan, nothing sits next to yesterday’s result, and last week’s findings are buried somewhere up the thread.

DotSet collects every recurring task into a board. Each task is a channel with its own column, and each run adds a card to it. Columns can be dragged into a new order, scroll on their own and page sideways as a set. Search, filters, bookmarks, Seen and notes work across all of them, so a result from last Tuesday is one search away instead of a long scroll.

The name comes from the same idea: every day’s card is a dot, and a channel is the set they form over time. The dots also run along the top of the board, one per column, and their tone shows whether that column is fully in view, partly hidden or off screen.

An exchange rate deserves a glance; a paper you might cite deserves ten minutes. A chat answer gives both the same treatment. DotSet lets the reading cost follow the value, through three controls: the shape the content takes, how far you open a card, and how much the agent writes in the first place.

Every card opens in three steps, and each step adds a kind of information rather than more of the same. Compact shows the title, source and a tag or cover, enough to decide whether to stop. Focus adds a larger image, a short summary and why it was picked. Deep View opens the full reading: findings, the agent’s interpretation, and the sources with what was actually read.

The newest card in each column opens at Focus. Moving between cards doesn’t mark anything as read; only opening Deep View does, so Seen means you really read it.

A recurring task has a value that rarely changes, so length is set per channel, not per message: Concise, Standard or Detailed. The exchange rate stays at one line; a reading list on history can run long. The setting applies from the next run, so the history keeps what was written and a short channel costs fewer tokens every day.

The dial never changes the glance. Compact is identical at every setting and Focus stays within the same few lines. What moves is the reading below it: Detailed adds the question, the method, the limits and more of the findings, while Concise keeps a few parts of a sentence or two each.

Not every result reads best as text. A rate wants a trend, a reading plan wants a timeline, an album wants its cover, a new word wants its sound. The agent doesn’t write interface code. It plans a layout from a fixed catalog (41 components and chart presets today) and the product renders it, so every screen stays legible, accessible and on brand.

A channel has to look the same every morning, so you learn where to look. DotSet plans a channel’s layout once, when its content first takes shape, and then binds each new day’s content into the same layout without another model call. It replans only when the content changes structure or you ask for a different view.

Each task runs in three stages. The first turns a plain sentence into a goal: what to find, the hard constraints, how often, and how the result should be shown. The second researches with search, reading and data tools. The third plans the layout. Everything else belongs to code: the schedule, the budget, which tools exist, and the checks before anything is published.

Those checks are what make a card worth trusting. A number in a table has to appear in a source the agent actually fetched, and percentages are computed by code, not written by the model. Every card says what was read, an abstract or the full text, and keeps the agent’s interpretation apart from what the source says. When nothing good is found, nothing is published.

A new kind of request is expensive the first time, because the agent has to find a way to do it. When a run succeeds, it can save the method it used. The method is kept only if the run’s own records show it worked, and it lapses after seven days. The next run starts from that method instead of from scratch, but fetches every fact again.

DotSet runs end to end as a desktop app and is getting ready for release. Most of the work now goes into the agent, one bad case at a time: each failure is kept, traced to its cause and fixed in the flow or in code. Cost came first, so that a routine run is budgeted at about a cent. Then the generated layouts, the accuracy of what the agent writes, and the detail dial above.

Next comes a calendar you schedule in plain words, and local files (papers, music, pictures) brought onto the board for the agent to sort, so the board becomes the one place to look each morning.

An agent becomes reliable through what is taken away from the model, not what is asked of it: everything that can be checked, from the schedule and the budget to the sources and the parts a reading must have, moved into code, and the model kept only the judgement nothing else can make.

And when a platform ships the feature you are halfway through, it shows the feature was never the product: what lasts is what one daily job needs and a general assistant doesn’t, the same shape tomorrow, a method remembered, a cost of a cent.