Changelog

Your own coding agents and hosted agents can share a room, see each other, and hand work to each other.

A room knows who is at the table now. Agents on your machine (Claude Code, Codex, Cursor) and hosted agents appear on one roster, and every agent prompt carries it.

• Any agent can ask another agent for help or propose a plan. A person still approves what runs.
• Set how many runs a room allows at once and a budget for hosted work, from the room.
• Agent to agent chains fold in the room. Agents can be asked to reply in threads, or to post reports only.
• Connect your own Claude Code with one command: claude plugin marketplace add pablostanley/hilos-agents. A Codex skill does the same.

The first live run with local and hosted agents passed. In-repo edits no longer stop for a permission card; the pull request is the gate. A question or permission that waits on a person now notifies them.

Everything that needs you lives in Activity. The board shows what is live in the room.

We had Tasks, Activity, the board, and a new page for decisions. That is one too many places to look, so we removed one.

• Activity carries what needs you, pending first, seen rows after, grouped by room. Its sidebar icon shows the count.
• The board opener sits with the room's tools beside Catch up, Pins, Call and Members. The board is grouped lists with a ten-row cap and seen marks.
• The same rows on iOS Home.

Agent replies lead with the answer and the next action. Report cards are body text and metadata.

An agent reply should read like a message from someone on the team, with the outcome first and the machinery a click away.

• Replies stop repeating progress every turn and stop offering follow-ups nobody asked for. Failure notes appear once.
• Report, plan and run cards use 14px body and 11px metadata. Status pills are plain text. Long task titles wrap.
• New workspaces start with a Hilo that plans a small first milestone, and room prompts for the agents actually present.

The first screens ask what you are making, who is coming, and which tools you already use. Each answer changes Home.

The welcome is a full-screen entrance now, and every answer pays off somewhere you can see.

• Your idea becomes an editable brief. Home offers one next action.
• Choosing your tools opens the right connection, or creates an agent if you have none.
• Save and close resumes on web and iOS.

Calls, agent setup, and run activity are native. Toolbars follow Apple's guidelines.

The public TestFlight beta keeps moving parts of the app from the web view into native screens.

• Audio and video calls with mute, camera, speaker and leave.
• Agent settings, memory, recipes and GitHub accounts use native forms and sheets.
• Back is a chevron, Close is a symbol, and task and doc links open native screens.

Also fixed on the web: Connect GitHub opens GitHub's account picker instead of relinking the only installation it can see.

The public iPhone beta has been rebuilt as a native app. Rooms, DMs, composing, and review now feel at home on iOS.

We replaced the old web shell with a native app for the parts of hilos people use every day. Build 2.2.0 (18) is live in the public TestFlight beta now.

• Move through native tabs, stacks, menus, and sheets, with Liquid Glass on iOS 26 and a quiet olive fallback on earlier versions.
• Write with formatting, mentions, custom emoji, GIFs, slash commands, photos, and files. Images open in a full-screen native viewer.
• Open Room details for catch up, pins, files, code, resources, environment, automations, members, and room controls.
• Overview, preferences, and complete people and agent profiles are native. Push notifications and hilos links can return to the room or thread they came from.

This is still a beta. Calls, Docs and Tasks, some workspace settings, agent administration, automation recipes, and GitHub installation still use the signed-in web app inside the native stack. Join from hilos.sh/download and tell us where the keyboard, notifications, links, big text, or emoji feel wrong.

Point at a preview, edit its text, retry a failed build, and choose where the code goes.

Making an app in a room has a few more handles now. The request, the version everyone can see, and the choice of what to keep stay with the conversation.

• Choose an element in the preview and the next message carries that exact target into the revision.
• Edit supported text directly without spending another model turn. A version choice posts back to the room.
• A failed generation offers Try to fix, and another revision waits its turn instead of colliding with work already running.
• See the credit estimate before a build, the actual use after it, and choose the GitHub destination when the work is ready to leave the room.

Direct editing covers text the preview inspector can identify. Other visual changes still go through the conversation.

Channels, Home, search, and live updates do less work before they show you the thing you asked for.

We spent a full pass on the parts of the room that had quietly become expensive. The result is less code on first load, smaller reads, and live updates that reconcile instead of drifting.

• Channel and workspace layouts stream in waves, while secondary panes and uncommon controls wait until you open them.
• Search runs its filters in Postgres, Home reads bounded activity, and every live database subscription carries a scope.
• Message rows, the sidebar, presence, unreads, and the composer stop rerendering for changes they do not own.

Warm production measurements on August 30: a 200-message room opened in 486 ms, common-word search p95 fell from 2,926 ms to 971 ms, and Home activity fell from 3,858 ms to 139 ms. A one-hour closeout pass found zero runtime errors.

See what an agent is doing, stop work from the run card, or leave a direction for its next turn.

The run card is becoming the control surface for work wherever it happens. The room shows the same facts without pretending every runtime has the same controls.

• Expandable activity traces show tool work, files touched, elapsed time, completion, and failures.
• Stop works across supported hosted and local runs. A direction left for a local agent is delivered at its next turn.
• A room budget can pause new hosted work and resume it when the limit is raised.
• Public research takes a read-only answer path instead of opening an unnecessary build run.

Local directions require hilos-agent 0.11.1 or newer. Each card says when a control is unavailable for that runtime.

When Hilo hands parts of a plan to specialists, the room can show who owns each piece and how it is moving.

A manager run and its specialist runs now share one durable record. The roster comes first, then each piece of activity links back to the work that produced it.

• Approved fan-out plans record the manager, every specialist, and the lineage between their runs.
• Manager activity and specialist activity stay separate on the card, with links between them.
• A failed activity update can be retried without inventing another run or losing the original record.

This path is early. It currently covers approved hosted fan-out in non-guest web rooms. Local-lane proof and native fan-out cards remain open work.

Keep more than one browser beside the conversation, choose the room icon together, and move through calmer threads and files.

A collection of smaller changes makes the room feel more like the group's place and less like a set of panels negotiating for space.

• The right panel keeps multiple browser tabs, and the artifact header leaves more room for the thing itself.
• Threads read as conversation cards, file grids adapt to their width, and the room can use a group-chosen emoji or icon.
• Pane resizing releases reliably, header controls stay under the pointer, and emoji and icon pickers share one familiar shape.
• Docs show a conflict before one edit overwrites another and update the open row when a teammate saves.

Ask for a small app or page. A live preview opens beside the conversation, without a GitHub repo.

A blank room can become a working thing now. The first version appears beside the conversation, then each revision stays with the same artifact.

• Start a page, site, or mini app without connecting GitHub first.
• Everyone in the room can follow the preview and its version history. A person chooses which ready version becomes current.
• Publish from hilos when artifact deployment is configured, or connect the chosen version to GitHub later.

This path is still early. Preview annotations, custom domains, environment setup, and direct source editing by external agents are not here yet.

Attach work from Framer, Lovable, or Paper and keep the proposal, review, and result with the conversation.

A room can now hold the thing your team is already making somewhere else. Agents work against the exact attached project, and the review comes back where everyone can see it.

• Framer changes use a branch and preview before a person chooses whether to merge them.
• Lovable and Paper work can be handed to a person's connected agent, with the request and result recorded in the room.
• Applying a reviewed change never quietly publishes it. Publishing stays a separate decision.

Each provider has a different execution lane. hilos names when work is direct, handed to a connected agent, or unavailable instead of pretending every tool works the same way.

Connect an account or create a private repository without losing the room.

The GitHub setup loop stays inside hilos now. Reuse an account you already connected, or name a new repository and come back to the same room with it attached.

• Already connected GitHub accounts appear as choices before hilos sends you anywhere else.
• Create a private repository under your GitHub account, with an initial commit and a main branch ready for the first run.
• The repository is yours. hilos uses the short GitHub approval trip to create it, then throws the temporary user token away.

Send a public link or ask a current question. Hosted and local agents can read the source before they answer.

A public URL no longer ends in an apology about not having a browser. The agent reads the page, keeps the source link, and answers from what it found.

• Hosted agents can search the public web and read public pages with bounded results and source links.
• Local agents keep their own web tools instead of losing them during the chat-routing step.
• Supported browsers can also expose the open hilos room as signed-in site tools, without another token.

Public web reading stays separate from connected-account data. Private addresses, credentials, and local network targets are refused.

Dictate a message, use more hilomojis, and move through lighter channels and threads.

A batch of smaller changes makes ordinary room time a little easier.

• Dictate into the composer in supported Safari, Chrome, and Edge browsers. Interim words revise in place while you speak.
• The composer renders your workspace hilomojis, and new workspaces start with a few more defaults, including wow.
• Channels and threads load fewer messages at first. Files, pins, and older replies wait until you ask for them.

Browser dictation is not available inside the Mac or iOS shells yet. The operating system's own dictation still works there.

Hilo picks up how a channel talks. Ask a hosted hilos agent to look at a branch and it goes to read it.

A studio room and a client room should not sound the same. Hilo now learns each channel's register from the people in it, then uses that voice without slowing the reply down.

• Answer an agent's last message without another @mention and it answers back. A plain closing like "thanks" gets a reaction instead.
• Reactions come from the room's own vocabulary, including custom emoji, ranked by what people there actually use.
• Ask a hosted hilos agent to inspect a branch or pull request and it opens a read-only run, reads the repo, and posts what it found. It cannot edit or push from that lane.

Voice profiles are kept per channel, ignore guest channels, and can be turned off in workspace agent settings. The read-only lane fetches branches before it disconnects the remote.

A hosted agent can inspect the repo and bring a plan to the room. It waits for approval before it writes anything.

Choose Plan when the team needs to agree on the shape first. The plan lands on the run card, where replies revise it and Approve starts the build.

• The planning turn cannot edit, commit, push, or open a pull request.
• Approval resumes the same run and provider session. When the build finishes, the usual pull request review gate still waits.
• Agents connected over MCP can also ask a question as a card with two to five choices. One click returns a recorded, structured answer.

Plan mode currently covers hosted hilos agents. Local daemon and Cursor-hosted plan mode are still separate work. Question cards are for MCP clients that can wait for the room, not the hosted sandbox.

Send the screenshot. The same run card shows the work, opens the diff, and lets you change course.

The run card has a few more doors now. You can inspect the work and intervene without hunting down the laptop running it.

• Screenshots and image attachments reach hosted hilos and local agents. The card also shows when an agent searches the web, reads a page, or starts a helper.
• Open a changed file to read its patch before approval. If the pull request moves after you looked, hilos refuses the merge and opens the new diff.
• Stop ends a hosted or local run. Steer queues a note for a hosted run's next pass on the same pull request.
• At a hosted hilos approval gate, pick a model for this run. A follow-up pass can resume the earlier session instead of meeting the codebase from scratch.

Steer works between passes, not in the middle of a tool call. Cursor-hosted and local runs say so when that door is unavailable. Session resume starts clean if its saved file is unavailable, and daemon transcripts remain opt-in.

Catch up on what changed and correct the record when it gets something wrong.

We kept calling the room the record while some of that record was still hiding in metadata. More of it is visible now, and people can correct it.

• Activity collects the last 30 days of merges, review decisions, automations, calls, and new members, with links back to the room.
• Report cards name who suggested the work and who ran it. If the origin is wrong, the credited person, requester, or an admin can correct it before the merge.
• An agent profile now separates a short Core from its other memory. People with permission can add, edit, move, or delete a note, and a person's correction cannot be silently overwritten.
• Owners and admins can publish a shareable agent card with its real run and pull request record.

Activity and agent memory stay out of guest-visible paths. Existing merge records are never rewritten when an origin is corrected.

Pick an agent role or an automation recipe. Every field stays editable before you save.

Blank forms are bad at giving you ideas. The new galleries give you a useful first draft and stay out of the way.

• Create a hosted agent from one of seven roles: reviewer, docs writer, release notes, triage, design assistant, test writer, or dependency updater.
• Start a channel automation from five recipes for failed checks, daily check-ins, finished tasks, merge recaps, or weekly summaries.
• A gallery choice only fills the existing form. A person can edit the setup and confirms it before an agent can run or spend credits.

Every agent template stays mention-only and editable. Automation recipes use the same admin gate and dispatch approval as a rule built from scratch.

Search from the picker or type /gif. The result waits in the composer so you can look, add a caption, and send.

The composer picker now has Emoji and GIFs tabs. Pick one and it waits in the draft like an attachment. Add the caption, then send when it feels right.

• Search GIFs or browse what is trending without leaving the composer.
• Type /gif or /giphy to open the same picker on the GIFs tab.
• A GIF keeps its own proportions in the message. It remains plain Markdown, so edits, search, exports, and agent posts keep working.

GIF search is signed-in only, capped at a PG-13 rating, and depends on the deployment's GIPHY key. If the key is missing, the picker says GIF search is not set up.

Messages appear when you send them. The model work around the room gets a quicker, cheaper default too.

A small pause in chat gets annoying fast. We profiled the live room and fixed the three places that were making ordinary conversation wait.

• Press Send and your message paints immediately, then settles over the same row when Supabase replies. If the send fails, the text returns to the composer.
• The 680 KB emoji search data now loads at idle instead of on the first focus, where it had caused two roughly 490 ms main-thread pauses.
• An uncommon agent icon now loads one small icon module. It used to pull a 4.3 MB decoded icon family onto the channel path.
• Planning, editing, replies, and classification now default to GPT-5.6 Luna, each with its own reasoning depth. Coding stays on Claude, and Best or provider-specific settings still win.
• We corrected the rates billing reads too: Luna moved from $1/$6 to $0.20/$1.20 per million input/output tokens, and Terra from $2.50/$15 to $2/$12.

Measured on the live app: the missing-message gap was 228 ms. A normal composer keystroke was already 0.1 ms median, so we left that path alone. One live Luna reply reached its first token in 570 ms and finished in 762 ms. Workspaces without an OpenAI key stay on Claude.

Give a channel small rules: when something happens, it replies, reacts, or hands work to an agent for your approval.

Open the channel menu and choose Automations. Name a rule, pick a trigger, add what happens. The channel takes it from there, within about a minute.

• Trigger on a matching message, a schedule, a PR merging, checks failing, a task completing, or a webhook from any tool that can POST.
• Reply with a template, react with an emoji, or ask an agent. The agent step files a task and proposes the dispatch... a person approves in the channel before any run starts.
• Every automation keeps its run history, admins build them, and everyone in the channel can see what is automated.

An automation never reacts to its own output, a re-enabled rule only sees new messages, and webhook keys are shown once and stored hashed. Automations can also be managed over MCP and the API.

While a hosted agent works, its card tells the story in sentences: what it is editing, what it ran, what failed.

A ten-minute run used to be a spinner. Now the live card narrates: "Editing lib/x.ts" becomes "Edited lib/x.ts ×3" when the agent moves on, file reads fold into one quiet line, and failures rise in red.

• Rows update in place instead of scrolling, and "+N earlier" expands the history when you want it.
• The full transcript stays one click away for the version with everything.

CI results and new pushes land as single updating cards in the PR's own thread, not scattered through the channel.

A pull request's thread now collects its whole story. When checks fail, one card says what failed and updates when they go green again. Pushes accumulate into one line instead of a scroll of notifications.

• Failures name the failing checks: "Checks failed on PR #41 → lint, tests". Routine green runs stay quiet.
• Pushes coalesce: "5 new commits · latest: address review", one card, updated in place.
• Check history stays in the thread. The channel still gets the merge update.

A channel can opt out of PR narration from its repo link settings.

Video attachments play inline now, and a reply starting with [1:23] becomes a comment pinned to that moment.

Drop a walkthrough or a motion test in a channel and it plays right there. In its thread, start a reply with a timecode like [1:23] and it turns into a chip that seeks the video.

• A dot under the player marks every timecoded comment. Hover to preview, click to jump.
• Once the video is playing, the reply box offers a one-tap "comment at this moment" button.
• Timecodes are plain text everywhere else, so search still finds them and agents can write them too.

Pick a color or an image for the whole call.

A call's background belongs to the room now. Pick from eight presets, dial in any hue with two sliders, or upload an image. Everyone in the call sees the same thing.

• Any color stays readable: tiles, names, and controls hold their contrast across every theme.
• Upload a JPEG, PNG, or WebP up to 4 MB. The image stays private to people who can access the call.

A REST API over your personal token, with docs written so an agent can use hilos from a single link.

Anything that can send an HTTP request can now act in your workspace as you: read channels, post, search, manage docs, tasks, and automations. Same permissions as you have in the app, same review gates for anything an agent starts.

• Mint a personal token in Settings, then curl /api/v1/me. The reference at /docs/api covers the rest.
• Docs are machine-friendly on purpose: llms.txt, raw Markdown mirrors, and an OpenAPI spec that CI keeps honest against the real routes.
• A fresh agent was handed nothing but the docs link and a token. It posted and read back on the first try.

Start a voice or video call in a channel or DM, then keep its thread and transcript with the conversation.

Calls now live inside the web workspace. Start one from the room header, keep talking while you move around hilos, and return to the call thread when there is something to write down.

• Use the compact dock for an audio call or open the stage for video, screen sharing, reactions, grid view, and speaker view.
• A DM can ring the other members and grow into a group call. Channel calls stay visible in the header for anyone who can join.
• Turn on the transcript in a supported browser when the room agrees. Everyone sees when it is on, and the attributed transcript lands under the call message when the call ends.

Calls are available in the web app, use direct peer connections, and support up to eight people. Native app support and a TURN relay are still in progress.

In alpha workspaces, invite a hosted agent to look up context or start work. The result stays in the call thread.

Add a hosted agent to a call and speak to it like another member of the room. It can look up the conversation, check a pull request, or start a run without losing the thread everyone is already in.

• The agent joins with its own voice and carries the channel, repo, and workspace memory context into the call.
• A spoken request can start a billing-gated hosted run. Progress and the report card stay under the call message, and a person still approves the merge.
• When transcription is on, the agent's lines join the record and the seated agent can post an end-of-call recap from that transcript.

Agent seats are enabled only in workspaces participating in the GPT-Live alpha. Other workspaces have people-only calls.

Point at a destination and hilos starts loading it. Recent threads reopen from memory while the server catches up.

Moving between rooms now takes fewer trips to the server. hilos keeps a short-lived copy of recently visited pages and thread replies, then replaces it with a fresh read.

• Hover over a channel, DM, thread, or workspace and hilos starts loading it before the click.
• Reopening a recent thread paints its replies immediately and checks for newer ones in the background. Older deep-linked threads load instead of stopping at an empty state.
• On phones, hilos skips desktop-only sidebar work and waits to load heavier panels until you open them.

In the measured production build, the initial JavaScript for Home, Tasks, and Threads fell by about 35 percent.

Fold sidebar sections, narrow wide conversations, and collapse large preview screenshots when you want less on screen.

These controls leave more room for the conversation without hiding the things that need attention.

• Click Favorites, Channels, or Direct messages to fold that section. The current room, mentions, and unmuted unread conversations remain visible.
• Turn on Channel container in Appearance to center messages and the composer in a readable column on wide windows.
• Channel descriptions now live in the channel-name menu, leaving room in the header for repo and pull request links.
• Preview screenshots on report cards can fold behind a caret, and hilos remembers the choice on this device.

Ask for another change in a pull request thread and the agent continues on that branch instead of opening a second pull request.

A pull request in a thread is now shared context for chat, hosted runs, MCP, and remote agents. Follow-up work stays attached to the review already in progress.

• Ask an agent to review or fix the pull request and it reads the same anchor before it acts.
• An owner or admin can instruct hilos to merge or close it. The action must point back to that person's message, so an agent cannot approve its own work.
• Task dispatch state now appears on the detail page, list, and board. You can cancel a live dispatch, and hilos blocks a duplicate while one is active.

An open pull request takes precedence over stale merged or closed links, and closing one releases its run from the thread.

The login page and invite card now offer Google alongside GitHub and email.

Use the Google account you already have to enter hilos or accept a workspace invite. The flow works on the web and through the system sign-in sheets in the Mac and iOS apps.

• While one sign-in method is running, hilos disables the other buttons so two OAuth flows cannot overlap.
• If the account email already belongs to a hilos profile, Google signs into that account instead of making a second one.

A half-written message comes back when you return to its channel, thread, or Home destination.

Start a message, switch conversations, and come back when you are ready. The draft returns to the place where you wrote it instead of disappearing or landing under a different recipient.

• Each channel, thread, and Home destination keeps its own draft, so moving between conversations does not carry text into the wrong place.
• Formatting, the cursor position, and uploaded attachments return with the message. A failed send keeps the saved copy too.
• Drafts stay on this device and are separated by account. hilos removes drafts after 30 days and keeps at most 60.

The composer saves a bounded TipTap document locally after edits and clears it only after the send succeeds.

Compatible MCP clients can track hilos runs as tasks and show report cards in the conversation.

The hilos MCP server now speaks the July 28 protocol while still answering older clients. Clients that support its extensions can follow long-running work and render the result without sending you to another tab.

• A hilos run can appear as a standard MCP task with progress, review context, and its final result.
• The get_report tool can render a self-contained report card inside clients that support MCP Apps. Other clients keep the complete text result.
• Connected agents can place an approval card in the hilos thread and wait for a person's answer before they continue.

The server advertises MCP 2026-07-28 through server/discover and continues to accept the earlier 2024-11-05 request shape.

Naming an agent in a source reference no longer calls it into the conversation.

Hilo could cite another agent's answer and accidentally summon a second reply. hilos now ignores source references when it decides whether an agent was addressed.

• Message, Doc, report, memory, and Task references can credit a source without waking an agent.
• Notifications still use the original reference, so the attribution remains visible without turning into another answer.
• The same agent cannot call the same specialist twice after one message from a person.

The trigger check removes bracketed source references and keeps an author-to-agent handoff ledger until the next person writes.

The room now follows the keyboard, and Return makes a new line instead of sending.

Opening the keyboard on mobile Safari could hide the composer, move the room, and leave the newest message below the fold. The room now resizes with the keyboard and keeps the end of the conversation in view.

• On phones and tablets, Return writes a new line. The send button is the clear way to send, while Command or Control + Return still works with a hardware keyboard.
• The composer, dialogs, sheets, and toasts stay above the keyboard rather than relying on the browser to move the page.
• The message list and thread pane keep the newest message pinned when the visible room shrinks.

The keyboard measurement covers mobile Safari, Chrome, and the iOS app without applying the inset twice. A real-device pass on animation timing remains.

Tabs respond on tap, and revisited pages show recent content while hilos checks the server.

Tapping around hilos used to leave the old screen in place while the next one loaded. Mobile tabs now respond immediately, and pages you have just visited can show their recent contents while hilos checks the server.

• Home, DMs, Threads, Tasks, and Docs now show the right shape, or recent content, instead of a blank pause.
• Search holds onto useful results while you refine a query and keeps the mobile sheet from changing size under your thumb.
• Files, pins, profiles, billing, connections, repo pickers, and other panels now wait with a matching skeleton instead of a premature empty message or a generic spinner.

Recent route snapshots stay in memory, are scoped to the signed-in workspace, and are always replaced by a fresh server read.

Hilo can now send approved plan work to Eve agents on your infrastructure.

Remote agents could already join a conversation, but Hilo left them out when it divided a plan among specialists. They now appear in the roster for review, advice, and analysis.

• A person still approves the plan before anything starts. hilos then sends the cited brief to the remote agent and keeps its answer under the plan card.
• Repo-changing work stays with coding agents. Remote agents take work they can finish through conversation.
• If the agent asks a question, the task pauses in the thread. The person's answer continues the same remote session and completes the task only when the agent finishes.

Remote runs stay on your infrastructure and use the agent's own models and tools.

A linked repo's agent rules live in Docs, with a pull request between each approved edit and the repo.

The file that tells coding agents how to work in a repo used to sit outside the conversation. hilos brings that file into the workspace without taking review away from GitHub.

• Link a repo and hilos adds its AGENTS.md to Docs, with CLAUDE.md as the fallback.
• A person's edit opens a branch and pull request. An agent without a write grant proposes the edit first, and a person approves it before hilos opens the pull request.
• If the repo copy changes first, the doc says it is out of date. hilos never pulls automatically; choosing Pull latest replaces the doc and keeps the earlier text in its history.
• No rules file yet? Create a starter AGENTS.md from the repo menu. It opens as a pull request too.

Coding agents that read AGENTS.md pick up the same synced file.

opencode can join as a local agent, keep its session in the thread, and ask for command permission in hilos.

opencode is now a local agent option in hilos. Its permission requests pause the real command while the room decides what happens next.

• Choose opencode when creating an agent and follow setup instructions written for its actual config format.
• A permission card shows the exact command with Allow once, Always, or Deny. Deny stops the tool rather than posting an advisory message after the fact.
• Follow-ups in one hilos thread return to the same opencode session, so the agent keeps its working context.

The permission bridge ships in hilos-agent 0.7.0. Saved rules match only the exact pattern shown on the card, and unanswered requests fail closed.

Connect Claude Code or Codex as yourself to share messages, update Docs, and manage Tasks from the terminal.

Work that starts in a coding session can land in the room without copying it by hand. The connection acts as you, with the same workspace access you have in the app.

• Read, search, and post in channels you can use, and edit messages you posted. Shared messages keep your round avatar and say which coding client they came from.
• List, read, search, and write Docs. Edits to a repo-bound rules doc still open a pull request.
• Create, list, and update Tasks, including status, assignment, notes, and PR links.
• Every member can set up the connection from Settings. Personal tokens and agent tokens use separate tool registries.

Leaving a workspace revokes that workspace's token automatically. Guests keep their existing message access and cannot use the Docs or Tasks tools.

Owners and admins can share a redacted run report outside hilos, then revoke it when the review is over.

A finished run can travel as a read-only link. Before the link exists, hilos shows the exact public preview and keeps people's names off unless you choose to include them.

• The public page shows the agent, run status, report, preview link, changed files, checks, and review decision.
• Secrets are redacted again when the page renders. Transcripts, neighboring messages, workspace details, and member lists stay private.
• Revoking a link deletes it. A workspace switch can disable every existing public run link at once.

Public links are unlisted, excluded from search indexing, and served without a reusable cache.

Push works in production now, with missed-message email and daily or weekly summaries when you want them.

DMs and mentions had too many ways to disappear after you left the tab. hilos now uses push, a delayed email for messages that are still unread, and optional summaries.

• A missed-message email waits ten minutes, skips messages you already read, and sends only for DMs or mentions.
• Daily summaries stay silent without activity. Weekly summaries may send a limited setup suggestion during a quiet week, at most twice.
• Missed messages, daily summaries, weekly summaries, and product updates each have their own email switch and unsubscribe link.
• A short permission primer now helps browser and Mac app users turn on notification banners without colliding with onboarding.

Permanent bounces and spam complaints now suppress future mail. Temporary delivery failures do not remove someone from their account email.

See hosted usage from the account menu or composer before you ask an agent to begin.

The current balance used to live in Settings, away from the composer where hosted work starts. Usage remaining now sits in both places.

• The account menu shows a compact balance and opens the breakdown between included and non-expiring credits.
• Composers show a quiet usage gauge only when the conversation can use a hosted hilos agent.
• The details explain whether a 100-credit coding run can start, when included usage refreshes, and which credits do not expire.

Local, MCP, remote, and own-key agents keep their existing free or provider-funded lanes and do not show the hosted usage control.

Revisit a channel or DM and its recent conversation appears immediately while fresh state loads.

Returning to a room used to replace the conversation with a loading skeleton. hilos now keeps a small session-only snapshot of recently visited rooms and reconciles it with the server in the background.

• First visits keep the normal loading state. Revisits show the cached conversation, then pick up edits, deletions, permissions, and new messages from the authoritative read.
• Reactions now render and work inside threads on desktop and mobile.
• Messages made only of emoji render at twice the normal type size, including skin tones, joined emoji, flags, keycaps, and workspace emoji.

The room cache stays in memory, is bounded, and disappears when the workspace session ends.

Your workspace agent now follows the conversation and pitches in. No @ required.

Until now, agents only spoke when spoken to. Hilo now reads new messages as they land and makes one quiet decision each time: stay silent, react, answer, or propose work. Silence is the default; the other three have to earn it.

• Share good news and Hilo might react. Ask a question the project record can answer and it replies, with a note saying why it joined in.
• Describe real work and Hilo drafts a plan card with suggested specialists. Nothing dispatches, and nothing is billed, until a person approves.
• Call an agent by name — "rex, can you take a look?" — and that agent answers, no @ needed. Works for hosted, remote, and local agents alike.
• Three switches in workspace settings — reactions, replies, work proposals — each with its own off. DMs stay out of bounds entirely.

Ambient decisions run as a quick, low-cost check with hard hourly caps, and every intervention lands in the actions log. When in doubt, Hilo stays quiet.

Connect a Framer project: agents publish previews into the channel, and the deploy button stays human.

Framer is the tenth connector, and the first with a full loop: an agent can hand design edits to Framer, publish a preview into the channel, and then wait — because deploying to your real domain is a button only a person can press.

• Paste a Framer project link and it unfurls with the project's name, publish state, and what changed since the last publish.
• Link a project to a channel and it lives in the header rail next to your repo, with its own menu: open in Framer, open the live site.
• Agents can check status, publish, and pass design requests to Framer's own agent — its clarifying questions flow back into the thread.
• A publish posts a preview card: the URL, the changed pages, a screenshot. The Deploy button on that card is for people only — no agent tool can reach it — and the card records who deployed, and when.

One Framer project per workspace for now. Framer's server API is an open beta, so if connecting misbehaves, write in.

Agents deployed on your own infrastructure can now join as members. No laptop, no sandbox, just a URL.

Some agents aren't a CLI on someone's laptop or a run in our sandbox — they're services you deploy yourself. hilos now speaks to those too, starting with agents built on Vercel's eve framework.

• Create an agent, pick Eve, paste your deployment's URL and token. A test connection reports the agent's name and model before you save.
• Mention it and the reply streams into the channel live. Each thread keeps its own session, so the agent remembers the conversation natively.
• "@agent stop" actually stops the remote turn.
• Replies run on your infrastructure, so they cost no hilos credits — the same free lane as agents you run yourself.

Remote agents think with their own models and tools; hilos stays out of their reasoning. They sit out plan fan-outs for now — that part is next.

Cursor agents work again — with live progress, session resume, and model presets.

Cursor's January CLI update quietly broke every hilos-launched run behind a workspace-trust gate. That's fixed — and while we were in there, Cursor caught up to Claude Code on the things that matter.

• Runs pass Cursor's trust gate at the right permission level, and older Cursor installs keep working too.
• Live progress landed: editing, reading, and running steps as they happen, with the files touched.
• Follow-ups resume the agent's own Cursor session instead of starting cold.
• Model presets — Tool default, Most capable, Balanced, Fastest — now work for Cursor, resolved against your own account's models at run time. No model id is ever baked into a join command.
• The docs now cover the reverse direction too: Cursor as an MCP client driving hilos, editor and headless both.

All of this rides hilos-agent 0.6.0, on npm now — update, or re-run npx. Stale Cursor CLIs should run cursor-agent update.

A run now leaves two things behind — a status card and a report — and stays in the thread you asked from.

Agent runs used to narrate: a growing pile of "still working" replies, and a status card that jumped to the top of the channel even when you asked in a thread. Both habits are gone.

• While a run works, one card updates in place: current step, files touched, elapsed time. No message pile.
• The full play-by-play still exists — the transcript is one click away from the report card.
• Ask an agent inside a thread and the whole run stays there: the status card, any refusals or failures, and the report.
• Request changes on a report card and the re-run lands in the run's own thread, not a new top-level card.
• Ask Hilo to break down work from inside a thread and the plan card — and everything it dispatches — stays in that thread too.

Every agent can keep durable notes now — and every note is readable by the team.

Agents used to start cold on every run. Now they can write down what they learn — conventions, gotchas, decisions — and read it back next time. And because an agent that remembers things you can't see is a liability, everything it remembers sits in the open on its profile.

• Agents remember, recall, and forget through three tools; notes persist across runs.
• An agent's profile shows what it remembers: every note, expandable, with edit and delete for its owner and workspace admins.
• New empty workspaces get a one-time offer to start with a small team: Hilo, plus Rex for PR review and Dot for docs. One click either way, and setup costs nothing.
• Agents are portable now: export any agent as a Markdown template, and create one by pasting or dropping a .md file.

Memory writes are redacted for secrets before storage and land in the actions log, including which run wrote them.

One Connect to code menu, and a channel header where every pill opens a menu. No dead ends.

The channel header grew up. Connecting code is one menu with four plain paths — existing repo, new repo, local folder, new local project — and everything already connected is a pill you can click for its options.

• Pick a path and you get only that path's setup. Hosted or local is an explicit choice, described honestly: cloud and team-wide, or your computer and personal.
• Every terminal command comes with one sentence saying what it does and where to paste it. Repo already cloned? The command starts with cd, not clone.
• Repo, folder, PR, and branch pills all open menus — open on GitHub, attach a PR, change repository, copy path, remove — and disconnecting warns about what goes with it.
• On a Mac, folder paths hand off to the Local Agents window prefilled. In a browser, the flow says plainly that the Mac app handles folders, and links the download.

The Mac app 0.1.8 carries the new handoff — it updates in place.

DMs to guests, repo pickers past 100 repos, codex runs that hung — fixed, mostly thanks to your reports.

A round of real-world fixes, most of them found by people hitting real walls. Keep the reports coming.

• You couldn't DM someone who joined your workspace as a guest — it failed with a raw database error. Fixed, without loosening guest isolation an inch.
• The repo picker only saw your first 100 repositories. If yours was number 114 — one person's was — no search would find it. It pages through everything now.
• Agents set up with codex exec hung for exactly ten minutes, then failed. The daemon now closes the pipe codex was waiting on; the fix ships in hilos-agent 0.6.0.
• If another workspace needs you, a dot appears on your workspace avatar, and the switcher shows a count per workspace — mentions and DMs, not ordinary unread noise.
• Mention an offline local agent you don't own and the notice now names its owner instead of telling you to start a daemon you can't. The owner sees a quiet connect card only they can see.
• Also: the app stays up when sign-in checks briefly wobble, and the sign-in code label sits centered, like it always should have.

Make something from nothing: create a project in the Mac app, let agents build it, and deploy it to a real URL.

You no longer need a repo, or a terminal, to start. The Mac app can create a brand-new project in a folder on your machine, agents work in it like any other room, and when there's something to show, a deploy is one ask away.

• Start a new project from the Mac app: pick a location, name it, choose a starter (empty, static site, or Vite + React).
• Link the folder to Vercel or Netlify once, then ask for a deploy or press the button on a report card. The live URL lands in the channel.
• Ready for a real repo? The connect popover now walks you through creating one on GitHub and linking it, prefilled.
• Connect commands now start with the right cd or git clone, so pasting one into a terminal just works.

Deploys run on your machine with your own Vercel or Netlify login. hilos never holds those credentials.

hilos has real plans now: Free, Pro, and Max, with hosted-agent credits that are simple to reason about.

Billing is live. Free stays genuinely useful: unlimited people, unlimited agents you run yourself. Paid plans add credits for the hosted agents that work when your laptop is closed.

• Pro is $20 per seat per month with 1,000 pooled hosted-agent credits per seat; Max is $50 with 3,500.
• Agents you run yourself, in the terminal or the Mac app, stay free on every plan.
• The first paid plan comes with a 14-day trial and 500 credits to spend before your card is charged.
• Need more in a busy week? Credit packs top you up and roll over; they never expire.
• Everything lives in Settings → Billing: plan, credit meter, invoices, and a plain-language plans sheet.

Hosted agents now route each task to a fitting model automatically, and you can tune or override all of it.

A quick reply doesn't need the model that plans an epic. hilos now classifies each hosted task — planning, coding, writing, quick calls — and picks a model to match, across Anthropic and OpenAI.

• A posture slider sets the trade: Thrifty, Balanced, or Best.
• Prefer one provider? Set a preference, or pin one exact model and routing steps aside.
• Per agent, a step-by-step grid shows what each kind of work resolves to, and lets you override any row.
• Every routed call is recorded, so you can see which models did what, and what they cost in credits.

Coding runs stay on Anthropic models for now; that lane is built on Claude Code. Everything else routes freely.

One slider sets a hosted agent's temperament: Careful, Balanced, or Ambitious.

Agents differ less by what they can do than by how much rope you give them. Behavior presets make that a real decision for hosted agents, at the workspace level and per agent.

• Careful proposes a plan and waits for a yes before touching anything.
• Balanced keeps today's manners: act on clear asks, check on ambiguous ones.
• Ambitious runs with it: more effort, longer runs, ship-ready output.
• Advanced controls sit underneath: autonomy and effort move independently when the presets don't fit.

Agents you run yourself keep their own tools' settings; presets steer the hosted runtime.

Claude Code, Codex, Cursor, Antigravity, Hermes, or any MCP client: your agent, your choice.

hilos is not a Claude product, or an OpenAI product. It's the room where your team and your agents meet, whichever agents those are.

• Pick a vendor when you create an agent and the connect dialog writes the right commands for it.
• Antigravity and Hermes joined the list, next to Claude Code, Codex, and Cursor.
• Anything that speaks MCP over HTTP can connect with a bearer token; the docs carry a generic recipe.

A new version of the hilos-agent CLI carries the vendor-specific launch commands; it's rolling out now.

Agent scope is now guaranteed in code and spelled out in the UI.

Before a team hands agents real access, someone always asks the same question: what exactly can this thing read? hilos now answers it, precisely, everywhere you meet an agent.

• A scope note on create, connect, and profile surfaces says plainly what an agent can reach: hosted agents see one repository at a time, and local agents see the folder you run them in, with the same access your coding tool already has.
• The local daemon strips every hilos token from the coding tools it launches; your agent's model never sees your hilos credentials.
• A strict mode goes further for local runs: an allowlist trims the environment the coding tool inherits, so far fewer of your machine's variables ride along.
• Adding an agent to a channel with no repo linked gets an honest notice, not a guess.

hilos.sh/docs is live: short guides for people, mirrored in plain Markdown for agents.

Getting started, connecting each kind of agent, hosted versus local, and what agents can see — written down properly and kept in sync with the product.

• Six guides with a proper sidebar and on-page outline, in the quiet register hilos works in.
• Every page has a Markdown mirror and a copy-page button, so you can hand a doc straight to an agent.
• An llms.txt index points crawling agents at the right pages.
• The scope and guarantee lines in the docs render from the same source of truth as the app, so they can't drift.

A quality pass across the surfaces you touch every day.

Small fixes compound. This round: text you can actually select, a sidebar you can resize, report cards that account for themselves, and a little confetti where it's earned.

• Messages are selectable and copy out clean, with author and time attached; drag-select works from anywhere in the room.
• Report cards now say who the agent worked for, how long it took, and which files changed; runs that report their checks get a verified line too.
• Mention an agent with a question and it answers in chat; mention it with work and it starts a run. No magic words needed.
• Point an agent at a brand-new empty repo and it seeds the first commit instead of stalling.
• Also: drag the sidebar to your width, crop avatars on upload, more one-tap reactions, roomier settings dialogs, and confetti when a PR ships.

Give Hilo a big ask and it plans the work, dispatches specialists, and reports back.

Mention @hilo with something fuzzy — a landing page and a blog post, say — and it breaks the ask into subtasks, proposes the right specialist for each, and posts one plan card. You approve; the room does the rest.

• The plan card lists every subtask with a recommended specialist. Swap any assignment or drop a row before approving.
• Approve once and each subtask dispatches as its own run, threaded under the plan.
• When everything lands, Hilo posts a single roll-up — one summary instead of six threads to chase.
• Nothing dispatches until a person says so. Approval stays with you.

Plans, subtasks, and dispatches now live on durable tables, so a mid-flight deploy or crash cannot lose a fan-out. This is the loop hilos exists for: a manager routing work to specialists, with a person at the gate.

Your workspace now opens on a Home built around your day.

Opening a workspace lands on a personal Home: a greeting for the hour, what's unread, what's in motion, what shipped, and what changed in docs — with Hilo one question away.

• Four glanceable tiles: unread messages, tasks in motion, recent shipments, recently edited docs.
• An ask-Hilo composer floats at the bottom. Ask anything, and aim it at a DM or any channel.
• A rotating piece of hilos art keeps the corner company — click it to shuffle.
• Home also lives in the sidebar, right under Search.

Workspaces without an orchestrator see a quiet Meet Hilo card instead of the composer; one click turns it on.

The iOS beta is open to everyone, and the Mac app updates itself.

No more writing in for an early build. The iPhone beta is one tap away, and the Mac app now keeps itself current.

• iPhone: join the public beta from hilos.sh/download — a TestFlight link and a QR code, no invite needed.
• Mac: updates download in place and apply on restart, with clear progress along the way.
• GitHub sign-in on iOS moved into the system sheet, so passkeys work properly.
• Menus across mobile became bottom sheets, and a gentle primer explains notifications before iOS asks.
• The app no longer reloads on a brief network drop — your draft and your place survive.

Working agents show live progress, and no run can hang forever.

An agent at work used to be a dot that said busy. Now it carries a quiet orbit around its avatar, shows you what it's doing, and leaves a transcript behind.

• Hover a working agent for a live card: current step, files touched, elapsed time.
• Claude Code can stream its steps into the room — run hilos-agent hooks install in the repo once.
• Report cards with a PR now show Vercel preview links with build status.
• Hosted runs keep a full transcript. Open the digest from the report card, or download the raw log.
• Runs that lose their runner — a laptop sleeps mid-task — now end honestly instead of orbiting forever.

Transcripts are redacted before they are stored — keys, tokens, and credentials never land on disk — and guests cannot read them.

hilos can now read your Notion, Google Drive, and Slack.

Connect a provider in workspace settings and its links become first-class citizens: they unfurl into real cards, and agents read what they point at.

• Paste a Notion page, Google Doc, or Slack thread and it unfurls with its real title and breadcrumb, not a generic preview.
• Mention an agent near a linked doc and it reads the content before answering.
• Your own agents get a read_link tool over MCP for the same access.
• One connection per provider per workspace. Admins can revoke anytime, and channels with guests never expose external content.

Connecting takes a token from the provider today; one-click connect is on the way.

Tasks got a kanban view, and docs remember their past.

The tracker and the wiki both grew up a little: work can be a board now, and a doc's history is a click away.

• Flip Tasks between rows and a board, and drag cards between status columns.
• Every doc keeps a revision history: see who changed what, compare against today, restore in two clicks.
• Doc pages show which docs link to them, and doc search ranks real matches first — for people and agents alike.

A design pass over the surfaces you touch all day.

Dozens of small decisions add up: the sidebar got a real hierarchy, the channel header became one piece, threads stopped shifting the page, and the appearance styles became genuinely different from each other.

• Sidebar: unread rows stand out, read rows recede, mentions get an ink pill.
• Appearance styles are structurally distinct now, with three new ones: Paper, Ink, and Terminal.
• Preferences reorganized into General, Notifications, and Appearance — including a 12/24-hour clock choice.
• Channels sort by recent activity again, threads open without layout shift, and unread badges got fixed.
• This dialog is new too: the what's-new deck is a real card deck now. Go on, drag it.

Sharp eyes may find something new at the very bottom of hilos.sh — and on recent Apple displays, the wordmark now glows a touch brighter than white.

hilos has a voice now — soft synth notes for sends, ships, and sign-ins.

Every sound is a small motif on one instrument: quiet, brief cues for everyday things, and a warmer bloom when something ships. Nothing beeps at you, and bad news stays silent.

• A soft note when you send, a gentle two-note when something needs you, a quiet chime when an agent replies.
• PRs get their moments — opening, approval, and a little bloom when one ships. Milestones ring grandest.
• Two voices: Musical (a soft, lofi synth — the default) and Minimal (plain digital ticks).
• Change it, or turn it all off, in Preferences → Notifications → Sound.

Every workspace now has an orchestrator that keeps work moving between messages.

Hilo is a new kind of member. It reads the room, briefs the team, answers questions from project memory, and routes work to the right agent — and a person approves every dispatch.

• A daily brief covers what shipped, what stalled, and what needs a decision.
• Away for a while? Hilo sends you a personal catch-up DM.
• Ask a question in a channel and Hilo answers from project memory, with citations.
• Hilo proposes tasks from conversation and suggests what to pick up next — you approve before anything happens.
• Routing cards suggest the right specialist for a job; approval stays with people.
• Agents can hand work to each other, with loop guards so nothing spirals.

Every Hilo behavior has its own switch in workspace settings, and everything it does lands in an actions log. Routing outcomes feed back into memory, so suggestions get better as the room learns.

A deep security pass across tenancy, guests, and agent tokens.

We attacked our own row-level security and fixed everything we found, then wrote live harnesses so the fixes stay fixed.

• Profile reads are now tenant-scoped: you only see people you share a workspace with.
• Guest isolation was re-verified end to end with a live test harness.
• Doc changes from agents go through an approval gate.
• Hosted-run agent tokens now expire automatically instead of living forever.
• A production audit now checks live database policies against the source of truth.
• Background email jobs got a CI gate after a middleware change quietly paused them.

Mobile got rebuilt: bottom tabs, a real Home, and navigation that feels native.

hilos on a phone is no longer a squeezed desktop. Navigation moved into bottom tabs, panes behave like pushed screens, and the whole surface got retuned for thumbs.

• Bottom tabs: Home, DMs, and your workspace, one tap apart.
• Screens push and pop like native views, with edge-swipe back.
• Long-press a message, task, or doc for its actions.
• A touch density scale: bigger type, comfortable targets.
• Docs and tasks hold up with the keyboard open.

Settings were overhauled and notifications got much finer control.

Every settings tab now earns its place: discrete controls save instantly, text fields save per card, and the pages are organized around what you can actually change.

• Per-channel notification overrides — loud channels can be quiet ones.
• Quiet mode for threads you're done with.
• People management moved into settings: roles, removal, and a guided ownership transfer.
• A Product emails toggle — opt out of update emails in one click.
• Agents can be set to chat only, so they discuss but never touch the repo.
• An accessibility pass across chat and core flows: live regions, focus traps, contrast fixes.

hilos.sh got a landing page that shows the whole loop, crocs included.

The public site now tells the story properly: your team and agents in the same room, planning in the channel and shipping from a thread.

• The pitch comes first; sign-in moved to the corner.
• A stack of crocodiles explains agents as members better than a paragraph ever did.
• An editorial FAQ, a two-minute demo, and reveals that fire as you scroll.

A Mac app and an iOS app are built and rolling out, and agents can now work in any local folder.

Both apps wrap the production web app, so improvements keep shipping instantly — with native shells where native matters: menus, badges, notifications, haptics, and push.

• Mac: native menus and notifications, a dock badge with your mention count, and deep links.
• The Mac app runs local agents natively — pick a folder, paste a join code, no terminal needed.
• iOS: a real app shell with safe areas, haptics on the interactions that deserve them, and push wired up.
• Email-code sign-in, which also makes logging in on phones nicer everywhere.
• A channel can now link to a plain local folder — no GitHub repo required — and says so in the header.

The apps are in the signing and distribution lap. Want an early build? Write to pablostanley1@gmail.com.

A built-in tracker: tasks and epics that you and your agents share.

Docs made hilos the place the team writes things down. Tasks makes it the place work gets tracked: lightweight tasks and epics, lived in by people and agents alike.

• Every task gets a short T-number you can drop into a message.
• Agents read and update tasks over MCP — assign one, and the work happens in the room.
• When the PR that closes a task merges, the task completes itself.
• Epics group related tasks so bigger pushes stay legible.
• Docs and tasks both got a clarity-and-delight pass on desktop and touch.

Agents and teammates can now record durable learnings that carry into every future run.

Hosted runs stay ephemeral, but what they learn no longer disappears. Agents can write down conventions, gotchas, setup fixes, and review lessons, and every future reply, run, and daemon task reads them back.

• A memory can be scoped to one channel (a project) or shared across the whole workspace.
• Agents write memories through MCP, and a request-changes or reject note is captured automatically as feedback.
• A new Memory page lists what the team has learned, with scope filters, editing, and deletion.
• Reach it from workspace settings or an agent's profile.

The workspace memory blob — the project's soul — stays as it was. This is the granular layer beside it: one entry per learning, curated by people, injected alongside the existing context.

Watch agents work in real time, then loop on the result without forking a new branch.

Agent runs now stream live into the room. A quiet card appears the moment a run starts and updates step by step — clone, setup, code, push, PR — then settles into the report card when the run finishes.

• The daemon and hosted agents both use the same live card.
• The native chat agent now streams its reply token by token with a caret.
• Reply in a thread to continue iterating on the same PR instead of opening a new one.
• "Continues PR #N" appears in the composer so you always know which branch you are on.
• One agent can now review another agent's PR and @-tag the author with findings.
• A failed run shows a clear error message instead of a silent "ended with an error."
• Mentioning an offline agent now posts an honest notice rather than staying silent.
• PR state and review decisions refresh automatically so the card stays current.

The runs entity (0279/0280) anchors a thread to a single active run so follow-ups know whether to iterate or branch. Session resume (0282) carries the agent's full context across iterations. Cross-agent review (0284–0291) is advisory only — the human stays the sole merge gate.

An onboarding email sequence now triggers when a new workspace activates.

Design polish landed across the marketing site and the connect-agent flow.

The connect-agent dialog is now a brand moment: full color field, editorial type, and an illustration. The home page's "why hilos" section uses the same bold masonry card treatment.

• Agent rows in the member list show a glanceable identity layer — runtime and last-seen state at a glance.
• Copy buttons now confirm with a brief checkmark.
• Product copy was tightened across the UI.
• Minor fixes: hero heading line height, crowd synth default volume.

Repo controls now work properly on narrow screens.

The repo and PR controls in a channel header now scroll horizontally on mobile instead of clipping out of reach.

• Connect, manage, and unlink actions stay tappable on narrow screens.
• On phones, the connect surface opens as a bottom drawer.
• On desktop, the same surface stays a popover.

We also tightened the public site: the logo marquee, footer wordmark reveal, video lightbox, and login crowd controls all got cleaner.

The main fix was small but important: the repo connect button could disappear behind overflow in the mobile channel header. It is now reachable.

The room now does a better job showing where you are.

Unread messages now start at a clear New divider, and opening a channel brings you to that boundary.

• When you read through the queue, hilos shows a quiet caught-up state.
• Agent avatars breathe while working, and typing dots now feel calmer.
• The composer got inline attachment pills.
• The landing page now tells the plan-to-ship-to-review story below the hero.

The goal was to make the room easier to read at a glance: what is new, what is done, and what an agent is doing.

Channel-scoped guests shipped, and a large security pass closed.

Guests can now join only the channels they are invited to. That keeps outside collaborators close to the work without giving them broad workspace reach.

• Invite privilege escalation, report-card XSS, and open redirects were fixed.
• API route authz, RLS, storage scoping, and MCP auth were tightened.
• Unfurls now reject internal IPs after DNS resolution.

Private attachments now use a protected bucket with signed URL proxying.

This was the trust day. A chat room that can invite people, host agents, and touch repos has to earn that access.

The public site got clearer, and shipping moments got easier to notice.

The homepage added a sharper tagline and a watch-demo lightbox. The root URL now resolves cleanly for social and chat unfurls.

• PR open and ship moments can notify the requester.
• The room can mark those shipping moments visually.
• Robot avatar illustrations landed for product and brand surfaces.

Workspace search now reaches more of the project record.

Search now includes docs, channel descriptions, repos, PRs, and matched thread replies. Results highlight the match and remember recent searches.

• Archived channels can be included on demand.
• Matched thread replies open in the right place.
• Hosted coding sandboxes can use hilos MCP to write back to the room and docs.

The GitHub repo picker moved to a searchable combobox, which makes linking a channel feel less like scrolling through a wall of repos.

As more project context moves into hilos, search becomes more useful for both people and agents.

Hosted agents became easier to review, and docs became easier to maintain.

Hosted agents now write clearer PR titles and can author commits as the right person with hilos co-authorship.

• Visual runs can attach preview screenshots to report cards.
• Docs gained WYSIWYG editing and Markdown round-trip handling.
• Doc tree drag-to-move, backlinks, and search improvements landed.

Local agent setup and review loops got sturdier.

The connect flow now includes model and permission presets that can live-reload.

• Request changes routes back to the daemon rework path.
• A review note can become the next iteration.
• Report cards now carry PR diffstat metadata.
• GitHub fetches are time-bounded.

Agents now read more context before acting.

Agents read more of the channel conversation instead of only the mention. The router also distills a clearer brief for coding tasks.

• Longer runs post progress heartbeats.
• Runs start with an instant acknowledgment.
• Agents now get clearer project context before they respond.

The room now gives agents more of the surrounding conversation, so replies can stay grounded in the work already happening there.

Agents can now ship from the channel.

Mention a hosted agent in a repo-linked room and hilos can clone the repo in a sandbox, run the coding provider, push a branch, open a PR, and post a report card.

• The run edits one status message through clone, setup, code, push, and PR steps.
• Approve, reject, and request changes now operate on hosted PRs.
• Safety guards enforce concurrency, daily caps, kill switch behavior, and timeouts.

A channel mention can become a reviewed code change, even when no local daemon is running.

Agent runs got better failure handling and longer-run plumbing.

Detached hosted runs and cron polling created a path beyond the five-minute route ceiling.

• Hosted worklogs can stream into a thread and salvage partial work.
• Commit identity and sandbox failure accounting were corrected.
• Agents now get clearer guidance when a channel has no repo linked.

The local agent path moved from plumbing toward setup flow.

Channels can now have one repo connection, and agents know that repo when they work.

• Agent profiles gained runtime, history, deactivation, and editing surfaces.
• The hilos-agent CLI added join flow and presence.
• The daemon gained setup docs, queue behavior, and stronger request-changes iteration.

The daily room experience got the basics it needed.

The composer gained formatting, slash commands, emoji typeahead, link editing, paste and drop files, and rich-message editing.

• Messages gained date dividers, polished rows, markdown images, lightbox behavior, reaction details, and long-message collapse.
• Unread state, mention badges, threads, pins, files, group DMs, and presence landed.
• Search filters, generic unfurls, and GitHub PR unfurls rounded out the core room model.

This was the sprint that made hilos feel like a daily room, not only an agent demo.

The first agent-to-repo loop came together.

MCP tools for channels, threaded messages, git links, report lookup, mentions, and workspace search landed.

• The local daemon runner can poll work, run a handler, propose changes, and flow through an approval gate.
• Token revocation shipped.
• GitHub helper tests, unit test infrastructure, and the verify-all harness were added.