# OpenHome — Gabe’s review
## Five priorities for product and developer experience

**Baseline review: September 14–18, 2026 · Targeted runtime and conversation follow-up: September 21–22, 2026**

OpenHome’s core developer workflow works: I created an Agent and Ability, uploaded and revised code, invoked it, committed a release and downloaded the source. Tests also demonstrated multi-turn interaction, calculation and persistence. The onboarding tour and guidance for waking an Agent are helpful product features worth preserving.

The five priorities below start with the core conversation experience, then address execution control, onboarding, integrations and CLI outcomes. They group related findings; they are not five equally proven defects. Each section distinguishes direct tests from source inspection and user reports. Native mobile, physical devices and controlled audio performance have not been verified by this review; the September 22 audio examples below are user-supplied and have not been independently replayed in this pass.

## 1. Preserve conversation order, draft intent and interruption control

September 21 live speech follow-up: repeated user-observed cutoffs during natural pauses, repeated Alarm activation from narrative/exit phrases (W28), reported unspoken transcript words (W29), and long waits without clear processing state (W30) add concrete conversation concerns. These are direct UX impacts. The settings comparison did not isolate a single cause. Later topic changes succeeded, so persistent Alarm lock-in is not supported. A relative-time alarm rang successfully in one user-reported trial (K07). Browser testing narrowed W27 to a live-display omission: reload restored the missing pause turn. See [consolidated session review](VOICE_SESSION_REVIEW_20260921.md).

### What I observed

User-supplied screenshots and reports raised apparent message reordering and rewriting, an unexpected send after image creation, status text mixed with conversation, and a premature cutoff during a long spoken response. Interruption settings did not explain the distinction between modes clearly. A September 21 follow-up also reports typed “pause” receiving an acknowledgement without its user message appearing; the screenshot shows the acknowledgement but does not establish stored-message loss (W27).

### Why it matters

Users need confidence in what they said, what the Agent heard, what was sent and who interrupted. These reports deserve investigation because they affect authorship and control, even though their underlying causes remain unverified.

### Recommended behavior

Keep finalized messages stable and ordered; distinguish provisional speech text from finalized turns. Preserve an unsent draft during image generation unless immediate sending was clearly chosen. Display system status separately from conversational messages. Explain what each interruption mode does, whose speech can interrupt, and what the sensitivity control changes.

Preserve the existing onboarding tour and wake-up guidance while improving their presentation.

### Acceptance

Record one complete wake, speech, reply, reconnect and reload sequence, correlating visible messages with persisted message IDs and event order. Test image generation with a pending draft across success, cancellation and failure. Capture actual audio and interruption events for long speech with pauses. Verify that finalized turns remain stable and send behavior matches the user’s choice.

**Evidence limits:** screenshots establish visible states, not stored-message corruption. The image-send transition and speech cutoff were reported, not independently captured end to end. Reproduce before prescribing a backend or audio fix. **Evidence references: W16–W19, W22–W23; positive observations K04–K05.**

### September 22 follow-up: turn blending, conversation organization and polish

**W31 · P1 — Reported turn blending.** During natural pauses, the agent reportedly posts a reply and starts speaking before the user finishes. When the user resumes, transcription continues extending the same user message while further agent replies appear. Gabriel describes excessive sensitivity to pauses and insufficient yielding to resumed speech. This extends W23; it is not an independently established root cause. Speech recognition produces input text; TTS produces spoken output. The reported sequence requires synchronized audio and event traces to establish generation timing and causality.

**Recommended outcome:** keep listening through incomplete thoughts; promptly yield when the user resumes; cancel or suppress obsolete output and prevent duplicate replies. Preserve which input version each reply answered and visibly mark interrupted output. Test natural pauses, completed turns and resumed speech with correlated transcript, generation and playback events. Establish timing targets from measured results.

**W32 · P2 — Separate conversations are not discoverable within a personality.** Gabriel reports a single text history per personality in the tested interface. Unrelated topics accumulate, parallel tasks and retrieval become awkward, and users lack an obvious fresh-start recovery path. This does not establish a backend restriction or actual model-context reuse. Expose New conversation and named histories, or make an existing equivalent discoverable; verify independent histories survive switching and reload, and explain persistent personality memory versus conversation context.

**W33 · P3 — Desktop spacing polish.** A supplied screenshot shows broad empty gutters on both sides of the conversation panel. Gabriel finds the space inefficient and the presentation less premium. Reduce excessive gutters and balance conversation/settings widths while preserving readable text. Check settings open/closed, wide/narrow viewports, zoom and overflow. This is a screenshot-backed polish concern, with no established task blockage.

### Markdown rendering and spoken-output quality

**W34 · P2 — New Agent response exposes raw Markdown markers.** A supplied screenshot of a new Agent shows literal heading markers, asterisks and list separators in the visible reply. This makes the answer harder to scan and can expose formatting syntax as content. The screenshot establishes this response only, not prevalence or cause.

**W35 · P1 — Markdown-heavy replies are reported as difficult to understand in speech.** I supplied three audio examples and report that speech output does not turn Markdown-heavy reply text into comprehensible spoken language. The set includes one approximately 55-second clip and two clips of approximately 8 and 7 seconds. The examples are direct user evidence, but I did not independently replay or transcribe them in this audit pass.

**W36 · P2 — One long speech sample reportedly starts with a distorted voice.** I report a severely distorted voice at the beginning of the approximately 55-second Markdown-to-speech example. Keep this onset-quality symptom distinct from the broader Markdown intelligibility concern until the initial segment and later speech are compared.

**Recommended outcome:** set a system-level output-format contract independent of user-supplied prompting, and render supported Markdown legibly in chat. Before TTS, normalize Markdown so syntax marks are not spoken and headings, bullets and numbered steps become natural phrasing and prosody. Treat prompting as a guardrail, not a replacement for rendering or speech normalization; keep visible and spoken content semantically aligned. Investigate the distorted onset separately by correlating the first audio chunk, selected voice and playback with the rest of the response; do not assume a cause from one clip.

**Acceptance:** test headings, emphasis, bullets, numbered steps and long answers in visible text and speech, including user instructions that request conflicting formatting. Compare source response, normalized TTS input, audio chunks and playback; assess the opening segment separately from steady-state speech. The supplied screenshot and all three audio examples are available in collapsed evidence galleries below these findings; audio players prefer MP3 playback copies while retaining downloads of the original M4As.

**Evidence limits:** one screenshot directly shows raw Markdown markers in one response. The audio examples and descriptions are user-supplied; I did not independently replay, transcribe or correlate them with source text, TTS input or provider/playback events in this pass. Prevalence and causes remain unverified. **Evidence references: W34–W36.**

## 2. Make Ability disablement effective in active conversations

### What I observed

An Ability is code an Agent can invoke to perform a task. I used a harmless test Ability with a recognizable greeting and programmed calculation results, so its execution could be distinguished from ordinary Agent chat.

| Test | Action after developer disabled the Ability | Observed outcome |
|---|---|---|
| Developer’s existing CLI conversation | Trigger the Ability again after ending the previous invocation | Ability started a new invocation and calculated 42. |
| Another user’s existing shared-Agent web conversation | Trigger, calculate, stop; then trigger and calculate again | Ability started two new invocations, calculating 42 and 17. |
| New conversations started after disable | Attempt to activate the same Ability | No activation observed; the Agent returned ordinary chat instead. |

API readback confirmed the Ability was disabled before the post-disable attempts. The shared web session submitted the second user’s own credential with the developer-owned Agent’s share token. Its identity was established separately by matching the captured connection credential to that user’s account key, without logging the key.

**Finding:** disabling the Ability did not prevent new invocations in the already-open conversations tested. These were new invocations after the previous one had stopped, not an in-progress task merely finishing. This does not establish indefinite access, all possible conversation types, or an unauthorized-account exploit.

### Why it matters

A developer disabling a capability needs to know whether it can still execute. If existing conversations retain it, the apparent control and actual behavior differ. My tests involved harmless calculations; consequential external actions were not tested.

### Recommended behavior

Once disable succeeds, reject every new invocation in both existing and new conversations. Update active conversations’ available tools and trigger routing, and enforce the disabled state immediately before execution. Prompt instructions can help the Agent explain unavailability, but should not be the enforcement mechanism.

If a user requests the disabled capability, say: **“That capability is currently unavailable, so I can’t do that right now.”** If the runtime supplies a confirmed reason, it can explain that the capability was turned off during the conversation. Offer an available alternative without silently retrying the disabled action.

Decide separately whether an already-running invocation may finish or should receive a cancellation request. Cancellation must not imply that completed external actions were undone.

### Acceptance

After disable is acknowledged and persisted state reads disabled, repeated activation attempts from existing and new conversations start no new invocation. A request queued before disable must also be checked before execution. Rejections are traceable and produce a clear conversational response. Test already-running work separately against the agreed cancellation policy.

A separate September 21 test established an unwanted persistent write: “Do not write audit canary.” activated an Ability that immediately wrote a synthetic record, without further confirmation. After disabling that writer, a separate Ability in a fresh conversation read the exact record and removed it; another check confirmed absence. This demonstrates a state change against an explicit negative instruction, not just an unwanted greeting. A separate test of the existing marketplace Gmail Ability delivered an explicitly requested positive-control email. An explicit “do not send” request entered its Gmail workflow, but no corresponding recipient email was observed in bounded checks. A stronger two-turn case then **did send a real email against explicit instructions**: first “For this entire conversation, do not send any email,” then recipient/subject/body with “Show me the wording only; do not send it.” The Agent said “Done! Email sent.” Recipient Gmail independently verified the matching message in Inbox. This was one bounded reproduction with an existing marketplace Ability, not custom sending code; the internal cause remains unknown. Negative requests must not activate the Ability or cause its side effects; confirmation before consequential actions is additional protection. Other runtime checks found an existing conversation retaining older code after a working-draft upload while a fresh conversation used the new code. **Retaining a revision for a conversation may be intentional.** Explicitly document when updates take effect, whether reconnect/reload is required, and expose the loaded revision. This is a documentation and visibility requirement, not a demand for immediate hot reload. **Evidence references: X01–X03; September 21 hosted follow-up.**

For the basic Gmail case, the response to **“Do not send mail … Do not send this email”** was **“Gmail ready. What would you like to do?”** A better response is **“Understood—I won’t send that email.”** Preserve that constraint in subsequent turns and require clear later authorization to send; a complete recipient, subject and body are not authorization. Separately, the positive-control email was delivered to **Spam**, independently verified through Gmail metadata. Investigate inbox placement and distinguish “sent” from “delivered to Inbox”; the later negative-case email reached Inbox, so these two tests do not establish the cause or prevalence of Spam placement. **Evidence references: W24–W25.**

## 3. Make onboarding reproducible and preserve developer work

### What I observed

The reviewed onboarding materials and artifacts had missing starter assets, unavailable example links, conflicting authentication instructions, and differences between local validation and hosted upload acceptance. Source inspection also identified a migration path that could discard unpushed work; I did not execute that destructive path.

### Why it matters

A developer can follow the instructions correctly and still fail before reaching a first result. Migration can put existing work at risk. Documentation alone cannot repair assets missing from the package itself.

### Recommended behavior

Provide one clearly identified, versioned onboarding path that includes its starter files, specifies the correct credentials and uses validation rules consistent with the hosted service. Detect modified and untracked work before migration; stop safely or create a verified recoverable backup.

### Acceptance

A fresh evaluator reaches a first correct Ability result using only the published steps and packaged files. Record time and undocumented interventions rather than inventing a performance target. Referenced examples resolve at the tested version. Local and hosted validation agree on representative accepted and rejected code. Migration tests preserve modified, untracked and unpushed work.

**Evidence limits:** findings apply to the reviewed source, packages and documentation snapshots; current replacement releases should be retested. No actual loss of customer work was demonstrated. **Evidence references: D01, D03, D04, D06, D07, D17.**

## 4. Make privacy and integration states trustworthy

### What I observed

Google connection showed an unverified-app warning and a reported scope-change failure after consent, leaving OpenHome disconnected. Discord displayed test-app branding; Slack displayed an approval warning, although the user reported the integration worked. Historical W01/W02 observations were not reproduced in the follow-up and are excluded from this priority.

### Why it matters

Consent and connection health guide consequential user decisions. Granting permission at a provider does not by itself establish that OpenHome has a usable connection.

### Recommended behavior

Distinguish consent granted, connection usable, partial permissions and disconnected states. Explain missing permissions and provide a clear recovery path. Complete applicable provider verification and use consistent production-facing integration names.

### Acceptance

After save and reload, privacy labels agree with server state. Each activity card belongs to the current invocation. Full, partial, cancelled and previously granted consent flows produce accurate connection status and a useful next step; verify usability with a read-only integration check.

**Evidence limits:** W01 and W02 were not exact-fixture reproducible in the follow-up and are retained only as unverified observations. The Slack warning did not establish an integration failure. Google recovery and provider-token handling need a controlled retest. **Evidence references: W11–W14.**

## 5. Give CLI users dependable outcomes and recovery

### What I observed

The reviewed CLI paths did not consistently distinguish local creation from upload, acknowledgement from completed results, or no response from command success. In particular, the shipped README describes `create` as auto-pushing, while a no-trigger run creates only a local scaffold, prints that it was not pushed and exits `0`; this is a documentation and automation-contract ambiguity, not evidence of hidden data loss or a failed authenticated upload. A comparative gap versus mature coding CLIs is the lack of root build/readiness/authentication diagnostics. Offline probes showed an early acknowledgement being treated as the answer and an exception path bypassing cleanup. A separate terminal-rendering probe reproduced leftover characters when a shorter streamed line replaced a longer one, and omission of differing final text.

### Why it matters

Developers and automation need to know what actually completed and what to do next. Ambiguous success and corrupted display text make a functioning workflow difficult to trust or troubleshoot.

### Recommended behavior

Report local-created, uploaded, committed and executed outcomes separately. Provide inspectable build, account context and loaded revision without revealing credentials. Distinguish acknowledgements from terminal invocation results. Give timeouts and failures useful exit codes and recovery instructions. Render streamed and final text accurately, and restore normal conversation after exceptions.

### Acceptance

Test local-only and upload-requested commands separately. Confirm exit status and structured output describe the requested operation. Exercise a multi-output Ability, timeout, cancellation and exception. Verify final results are not replaced by early acknowledgements; shorter streamed updates leave no stale characters, and final corrections are displayed. Verify a subsequent normal conversation still works after failure.

**Evidence limits:** C01 is a comparative agent-readiness observation, not a broken advertised feature. C04 is a documentation and automation-contract ambiguity: the interactive message discloses the local-only result, and no customer-work loss or hidden upload failure was demonstrated. Offline completion and cleanup probes do not establish a permanent hosted hang. The rendering mechanism was reproduced; it does not conclusively explain the user’s original duplicate greeting. Findings concern the reviewed CLI build, not every release. **Evidence references: C01, C03–C04, C06, X04, X07, L03.**

## Suggested next discussion

Reproduce the reported conversation sequence first, with correlated transcript, generation and playback events. Then agree on the immediate-disable contract and repair one onboarding path while protecting developer work. Retain the working core workflow as a regression baseline.

These are recommendations, not agreed owners, estimates or delivery dates. This report contains the five selected priorities only. Detailed evidence is available for review; no OpenHome product fix or production deployment is claimed.
