How agents work
What actually happens when you send an agent a message: the upfront plan, the steps that flip from pending to done, the lanes that show real findings, honest failure markers, and why what you see live is what you see after a refresh.
Most AI tools give you a spinner and then a wall of text. You have no idea what happened in between — whether it searched, what it found, what it skipped, or whether the confident-sounding paragraph is built on anything at all.
Unyo agents work in the open. Every run is a visible sequence of steps you can watch, expand, and check. When something fails, it stays on screen as a failure. When an agent had nothing to report for a step, it shows you nothing rather than inventing something. And when you refresh the page, you get the same record back — because the live view and the reloaded view are built from the same event stream, not two code paths that drift apart.
This page explains what you're looking at.
The run: from your message to the answer
When you send a message to an agent at Chat → your agent, here's the sequence:
- The orb. A small typing indicator appears between your message and the transcript. It means the agent is deciding what to do, and nothing has happened yet.
- The plan (most agents). If the agent knows the shape of the job up front, it declares all its steps at once — you see the total immediately in the step counter at the top of the run, and you can open it to read the whole plan before the work starts.
- Steps flip. Each step appears the moment it actually starts, spins while it runs, and resolves to done or failed.
- Lanes fill in. Expand any step to read what the agent actually found or decided at that moment.
- Artifacts appear. The moment the agent produces something real — a social post draft, an image, a document, a website — it opens in the side panel next to the chat.
- The reply lands. The written answer arrives after the work, not instead of it.
Not every agent draws a plan
The upfront checklist comes from a planning step that not every agent has. Tyron (images and audiovisual) doesn't have it — he chains image work and announces each step as he starts it, with no checklist ahead of time. Steve (websites) has his own display entirely: instead of steps, you watch the code being written into a file tree in real time. Everyone else plans first.
Steps are labelled in your language, with the real object
A step doesn't say image.search. It says "Searching for images of Lisbon" — in your interface language, with the actual thing the agent is working on pulled out of the tool call as it runs.
That label is not the agent narrating what it intends to do. It's built from the arguments the tool was actually invoked with, at the moment it was invoked. If the agent tells you it's searching for Lisbon, it's because the search really went out for Lisbon.
The step labels follow your interface language, which is separate from your agent language. Set your agents to reply in Japanese while keeping the interface in English, and the steps stay in English — the setting that changes what the agent says never changes what the product labels.
Expand a step to see the real findings
Click any step and it unfolds into a lane. Inside you get, in order:
- The action — a small pill naming the concrete operation, with an icon for its family.
- The beats — what the agent found, decided, or hit. Plain sentences, not raw tool output.
- Sources — when a step consulted the web, a Sources chip lists the real domains it read.
- The provenance marker — when a decision came out of your Neural Core rather than a fresh lookup, the beat is marked as memory.
Three rules are enforced in the rendering code, and they're the whole point:
| Rule | What it means for you |
|---|---|
| Nothing is fabricated | A step with no narration renders as a bare chip. If the agent had nothing to say about a step, you see nothing — not a plausible-sounding filler sentence. |
| Failures stay failed | A step that failed keeps an amber ✗ and its error beat. Failures are never quietly folded into a success. |
| The label carries the real object | Step titles are built from execution-time arguments, not from the agent's intentions. |
Read the lane before you trust the answer
If an agent gives you a confident summary, expand the research step. You'll see which sources it actually opened. A conclusion whose lane is thin is a conclusion worth questioning — and now you can tell the difference without leaving the chat.
Live and reload show the same thing — by construction
This one is architectural, not a promise.
Both the live stream and the reloaded page run the same reducer over the same run events. The streaming view isn't a fancier renderer that happens to look similar to the persisted one — it is the persisted one, fed live. There's no second code path to drift.
So: refresh mid-run, close and reopen the conversation, come back tomorrow. The steps, their statuses, the artifacts and the failure markers are all still there, in the same order.
Two honest exceptions
The lane beats are richer live than after a reload. The detailed discoveries inside an expanded step are a live and in-session view today; the reload parser rebuilds the steps faithfully but drops that inner narration. If a specific finding matters to you, read it while the run is fresh or copy it out.
Your work survives a closed tab
The agent runs on the server, not in your browser. Closing the tab doesn't stop it.
When you come back to a conversation whose run is still going, Unyo detects the detached run and starts watching it for you — checking every few seconds and materialising the result the moment it lands. If the run finished while you were away, it's simply there in the conversation.
The watching is deliberately bounded to about four minutes. The comment in the code that governs it reads "stop claiming live work (honesty over hope)" — past that point the backend deadline has long passed, and pretending to still be streaming would be a lie. If a run genuinely didn't finish, you'll see its last real state, not a spinner forever.
Send that, close the tab, make a coffee, come back. The draft card is waiting in the conversation.
When an agent needs a tool you haven't connected
Agents don't fail on a missing connection, and they don't pretend they succeeded either.
If an agent reaches for something you haven't linked — say Ashley needs Instagram and you've never connected it — the run pauses. The step indicator turns orange and a Connect card appears in the chat with a direct link to the right integration.
Connect it, and the run resumes on its own, from exactly where it stopped. You don't re-type anything. A watcher on the connection fires the instant the link lands, and the stream picks back up. If the resumed run then needs a second thing you haven't connected, it pauses again and the same cycle repeats.
Auto-resume has a 24-hour window
Resuming a run costs credits, so it can't be allowed to fire from a stale wait. If you connect the missing tool more than 24 hours after the run paused, it will not auto-resume — the wait is cleared and you'll need to ask again. This limit is enforced both in the app and on the server. Reconnect the same day and it just works.
The side panel and artifact cards
Real work needs somewhere real to live. When an agent produces something, it doesn't get pasted into the chat as text — it opens in a panel beside the conversation.
| What the agent made | Where it opens |
|---|---|
| Social post draft | Side panel — editable caption, hashtags and image |
| Image | Side panel canvas |
| Document | Side panel editor, with inline citations and a references list |
| Spreadsheet | Side panel with real sheet tabs and export buttons |
| Website | Steve's builder — code tree, live preview, per-edit diffs |
| Email draft | Stays in the chat as an editable card — deliberately |
That last row is a decision, not an oversight. An email draft's natural home is the conversation: auto-opening it in the panel duplicated the card and shoved the chat aside, so the panel now deliberately ignores email drafts. You can still open one full-screen by clicking its step.
The panel is yours to shape:
- Drag its left edge to resize it. Your width is remembered across sessions (between 360px and 900px, capped so the chat column always stays usable).
- Each conversation remembers its own panel — whether it was open, and what was in it. Open one conversation with the panel out and another with it closed, and both stay that way.
- The sidebar gets out of the way on its own when the chat column would get too cramped — and permanently defers to you the moment you toggle it manually.
- Escape closes the panel, and a panel you closed won't pop back open for the same artifact.
Reloading never hijacks your screen
Auto-open fires only on live work. Reopening an old conversation restores the panel exactly as you left it — it will never spring open at you because a three-week-old run once produced an image.
Steve is different on purpose
If you open a conversation with Steve, the website builder, the transcript looks like a developer's terminal rather than a checklist: monospace lines naming each operation, a spinner that resolves to ✓ or ✗, and the result folded underneath.
That's because Steve's work is the code. Instead of announcing steps, he writes files, and you watch them being typed into a file tree in the panel, with the file currently being written marked live. Every edit he makes to an existing file shows up in the transcript as a red/green diff, so you can see exactly what changed and ask him to change it back.
Everything else on this page — live ≡ reload, work surviving a closed tab, artifacts in the panel — still applies. Only the display differs. See the website builder for the full story.
How to get the most out of it
- Watch the first run end to end. It's the fastest way to learn what an agent actually does versus what you assumed it does.
- Expand the step you're least sure about, not the ones you already believe.
- Check the Sources chip on any research step before you quote the result.
- Connect a tool the moment an agent asks. Same-day reconnects resume automatically; you lose nothing.
- Ask for the work, not for a description of the work. "Draft the post" produces a card you can edit. "Tell me how you'd write the post" produces a paragraph.
- Don't fight the panel. If it's covering something, drag it narrower — the width sticks.
FAQ
Why does one of my agents not show a plan?
Because it doesn't have one to show. The upfront checklist comes from a planning capability that Tyron and Steve don't have. Tyron announces each step as he starts it, with no plan ahead of time. Steve shows you code streaming into a file tree instead of steps. Every other agent plans first, then works the plan.
I refreshed the page and the details inside a step are gone. Is that a bug?
It's a known limit. The steps themselves, their statuses and their artifacts all rebuild faithfully from what was persisted — that part is guaranteed by construction. But the detailed beats inside an expanded lane are live-and-in-session today, and the reload parser drops them. If a particular finding matters, read or copy it while the run is fresh.
A step failed. Why didn't the agent just retry silently?
Because a silent retry is indistinguishable from a lie. A failed step keeps its amber ✗ and its error beat on screen permanently, so you always know which part of the answer rests on something that didn't work. Agents do recover from many failures on their own — but the failed attempt stays in the record either way.
I connected the tool but the run didn't resume.
Check how long the run had been waiting. Auto-resume is capped at 24 hours: because resuming costs credits, a wait older than a day is deliberately not allowed to fire itself. Just send your request again — the connection is now in place, so it'll go straight through. If the wait was recent and it still didn't resume, the connection may not have landed; open Integrations from the sidebar and confirm the account shows as connected.
Do agents ever do things without showing me?
Not in the transcript sense — every tool call an agent makes streams into the run timeline. And the bigger boundary is upstream of that: agents draft, they don't send. Unattended sending and unattended publishing don't exist in Unyo, including for scheduled work. An agent prepares something; approving it is always your click.
Can I see what an agent did after the fact?
Yes — open the conversation. The full run record is persisted: the plan, every step and its status, the artifacts, and the failure markers. What you'll get back is the same view you'd have seen live, minus the in-lane details and the elapsed timers noted above.
Troubleshooting
The agent is replying but I see no steps at all. Some replies genuinely need no tools — a direct question gets a direct answer, and there's nothing to show. If an agent is clearly doing work (searching, drafting, generating) and you're seeing no steps whatsoever, reload the conversation; the persisted record is the source of truth and will fill in.
The panel opened over something I was reading. Drag its left edge narrower, or press Escape. Both stick: the width is remembered across sessions, and a panel you closed won't reopen for the same artifact.
A run looks stuck. Check whether the step indicator has turned orange — that's a pause waiting on a connection, not a hang, and there'll be a Connect card in the chat. If it's not orange and nothing has moved for several minutes, the safest move is to reload: the page rebuilds from the persisted run state and will show you the real outcome rather than a hopeful spinner.
I closed the tab mid-run and now I can't tell if it finished. Reopen the conversation. If the run is recent and still going, Unyo picks it up and watches it for you. If it already finished, the result is simply in the conversation. If neither, you'll see its last real state — which is the honest answer.
Steps are in a different language than my agent's replies. That's intentional. Steps follow your interface language; replies follow your agent language. Both are in Settings, and they're deliberately independent. See languages.
Next: The 10 agents and what each one owns · Delegation — agents handing work to each other · Security and privacy