What's new in Goatfied.

Sep 16, 2026

A question the agent asks always reaches you

A thread could sit for half an hour saying it was waiting for your answer while showing you no question to answer. The question was there all along, filed under the wrong part of the conversation.

A conversation is laid out by pairing each thing you asked with the work that followed it. Which part of the thread a given step belongs to was being decided by the order those steps happened to arrive in, rather than by when they actually took place — and those are not always the same thing, because catching up after a dropped connection can deliver something out of sequence.

When that happened at the start of a turn, the whole of the agent's work was attributed to the previous request instead of the one you had just sent. The newest part of the thread was left holding almost nothing, and everything the agent had really done was tucked away under an earlier message that had long since been folded out of sight.

A question waiting on your answer went the same way. The status line reads the whole conversation, so it correctly said the agent was waiting for you — but the question card itself had been filed further up the thread, behind a collapsed section. The run sat blocked, the agent waited, and there was nothing on screen to click.

Steps are now placed by when they happened rather than when they arrived, so a question always appears against the request that prompted it and the status line can no longer disagree with what you can see. Conversations already affected are repaired as they are opened, so a thread holding a question you never saw will show it again, options intact and still answerable.

• The question is where you are looking — A question appears against the request that prompted it, not buried under an earlier one.
• No more waiting on nothing — If the thread says the agent is waiting for your answer, the question is on screen and ready to answer.
• Turns keep their own work — What the agent did for your latest request stays with that request, however the updates happen to arrive.
• Existing threads are repaired — A conversation that lost its shape before this release finds it again when you open it.

Build 2.31.33

Sep 10, 2026

The agent stops wasting your time on its own tools

A single search could bury the agent under hundreds of megabytes, finished commands reported hours they never took, and asking for several things at once threw all but one away. All four are fixed.

Four faults in how the agent used its own tools were quietly costing whole sessions, and each one wasted your time in a different way.

Searching the project was capped by the number of matches rather than how much text those matches held. One line of an imported — and long since irrelevant — conversation history could be hundreds of megabytes on its own, so a single search handed the agent more text than it could hold and it spent the next stretch of the session picking through the wreckage. Each result is now trimmed to a readable snippet that says how long the real line was, so a search stays a pointer to the file and the agent opens what it actually wants to read. Imported editor history is no longer searched at all.

A command left running in the background was timed from when it started to whenever its result was collected, not to when it finished. A check that took forty-six seconds could therefore be announced as having taken fifty-four minutes. That number reads as the cost of the command, and it sent the agent hunting for slow builds that had never happened. A finished command now reports how long it truly ran.

When the agent asked to read several files in one step, only one of them was actually opened and the rest were dropped without a word — so it asked again, one file at a time, and every one of those round trips was time you sat waiting. Those reads are now gathered up and run together, which is what they were always meant to do.

The same flaw had a sharper edge. If the agent asked to run something and read something in a single step, the part that would have changed anything was the part discarded, and only the harmless read went ahead — so a command it believed it had run had never run at all. Now the action that does real work is the one that survives, and it still happens strictly one step at a time, so nothing is reordered and nothing is lost.

• Searches stay readable — A result is trimmed to a snippet instead of dumping an entire file into the agent's working memory.
• Timings you can trust — A finished command reports the time it actually took, not the time until someone looked at the result.
• Fewer round trips — Reading several files in one step now reads all of them, instead of dropping all but one and asking again.
• A step is never quietly skipped — When the agent asks to do something and read something in the same step, the action still happens rather than being dropped.

Builds 2.31.31, 2.31.32

Sep 9, 2026

Reconnecting no longer rewrites the conversation

A thread that reconnected could quietly copy itself, burying a question the agent was waiting on and holding back new replies until you typed again. Reconnecting is now invisible.

When a thread reconnects, everything that happened while you were away is sent again so nothing is missed. That catch-up was being added to the conversation rather than matched against what was already there, so a long thread could end up holding several copies of itself — the same reasoning, the same steps, repeated over and over.

The damage was not just clutter. A conversation is laid out by pairing each thing you asked with the work that followed it, and every duplicate looked like the start of another turn. The pairing slid out of step, so the newest reply was filed under an older message and appeared to be missing — which is why nothing seemed to arrive until you sent one more prompt and forced the thread to redraw. A question waiting on your answer could be left stranded the same way, so you never saw it.

A thread now recognises the parts it has already seen and keeps only what is genuinely new. Replies appear as they arrive, a question the agent asks reaches you straight away, and reconnecting as often as the connection requires costs nothing.

Conversations that were already affected are repaired as they are opened, so a thread that lost its shape before this release finds it again rather than staying tangled — including any question that was left buried in it.

• Updates appear as they happen — New replies show up on their own, instead of only once you send another message.
• A waiting question reaches you — A question the agent is blocked on stays visible in the thread rather than being buried by a repeated history.
• Long threads stay in order — Each reply stays with the message that prompted it, however many times the connection drops.
• Existing conversations are repaired — A thread already affected is put back in order when you open it, rather than staying that way.

Builds 2.31.29, 2.31.30

Sep 9, 2026

A silently dropped connection no longer looks like thinking

A thread could sit on “Thinking” for hours while the agent had long since carried on without it. The app now notices the silence and reconnects by itself.

Some connections do not announce that they have gone. A network that drops the link quietly, a laptop that sleeps, a change of network — any of these can leave the app holding a connection that looks perfectly healthy but will never deliver another word. Because nothing appeared to be wrong, no attempt was ever made to recover: the thread simply sat on “Thinking”, sometimes for hours, while the agent went on working out of sight.

The app now watches for that silence. When a running thread has heard nothing for long enough that the connection cannot still be alive, it reconnects on its own and replays everything you missed, so the conversation picks up exactly where it left off — including a question the agent had been waiting on you to answer.

A prompt you send can also no longer go missing. If anything went wrong between pressing send and the message reaching the agent, the field was already empty and the text was gone for good. Your message is now handed straight back to you, along with anything you attached.

• Dead connections recover themselves — A thread that has stopped receiving reconnects automatically and replays what you missed, instead of waiting forever.
• A pending question resurfaces — If the agent asked you something while the connection was down, it reappears once the thread reconnects.
• Your prompt is never lost — A message that fails to send comes back to the field with its attachments, rather than disappearing.

Build 2.31.28

Sep 7, 2026

Frozen conversations and invisible reasoning are fixed

A long run used to stop updating mid-flight, and the model's reasoning was never readable. Both are fixed, and the prompt field now remembers what you typed.

A run could stop updating while the agent kept working, leaving you watching a transcript that had quietly stopped moving. The connection was fine; nothing was being sent down it. It happened most often when the agent was busiest — a large diff or a long stretch of tool output would make the update stream fall behind, and the connection would be closed as though it had died. Quiet connections are now held open, and a brief interruption is retried instead of abandoned after a single attempt.

The model's reasoning was also invisible. When it thought out loud, the reasoning block appeared and folded itself shut in the same instant, so there was nothing to read. It now stays open while the turn is running and folds only once the turn is finished.

A prompt you have typed but not sent is kept, even if you switch to another session and come back. The field used to discard unsent text the moment you left, so a long message you were still composing disappeared if you glanced at another thread.

Stepping back down through your prompt history now returns to an empty field instead of stopping on the last prompt you sent, so the key that recalled a message can also clear it.

• Conversations stay live — A long run no longer stalls mid-flight. The transcript keeps updating even when the agent is busiest.
• Reasoning is readable — The model's thinking stays on screen while the turn runs, instead of vanishing the instant it appears.
• Drafts are kept — An unsent prompt survives a session switch, so you can leave a message half-written and come back to it.

Build 2.31.27