Skip to content

Latest commit

 

History

History
660 lines (573 loc) · 45.3 KB

sky-computer-use.md

File metadata and controls

660 lines (573 loc) · 45.3 KB

Sky Computer Use

Maintainer: OpenAI. Role: proprietary ChatGPT/Codex desktop Computer Use implementation and optional architecture benchmark, not a required provider.

This is the comprehensive entry point for the observed macOS architecture and security posture. Initial evidence was collected on 2026-10-03 and consolidated on 2026-10-04; the native efficiency follow-up is dated 2026-10-14. It describes pinned installed artifacts, not a vendor security specification or a guarantee about later releases. Exact inputs and experiment records remain in the spike; implementation decisions remain in the topics.

Current: Sky has a real native process-identity admission check. It is not just an obscure socket name. However, an admitted signed interpreter chain does not prove an official Codex session or trusted script provenance. A separate external MCP client also performed user-authorized TextEdit actions through the genuine runtime and normal approval wrapper. These observations do not establish unrestricted arbitrary-process desktop access, nor do they establish hostile same-user containment.

Reading map:

License and provenance

The research repository is kzahel/machine-control-spike (private; repository access required), with default branch main. For local work, check it out beside machine-control as ../machine-control-spike. The evidence links below pin the published snapshot 674b756 rather than depending on a local checkout or a moving branch. Later experiments must record their own snapshot before updating these references.

The installed Computer Use plugin declares Proprietary. No separate open-source license grant was found in the bundled @oai/sky package manifest; do not infer one from its readable JavaScript. The separate Codex repository declares Apache-2.0, which does not relicense the desktop service or runtime. No proprietary code or assets are adopted. Exact versions, source revision, artifact hashes and inspection paths live in the caller spike review and external MCP experiment.

Evidence and architecture

Current (2026-10-03): source-reviewed for the distributed Mac JavaScript transport and approval wrapper, supplemented by static native control-flow reconstruction. Bounded native discovery, runtime bridge placement, version-ping admission and an external MCP host operating TextEdit are live-tested on a physical Mac with explicit user authorization. The TextEdit test includes an independent saved-file effect check; full isolation and platform conformance remain open. Official documentation describes macOS and Windows support; this authorization review covers only macOS.

Layer Finding Evidence limit
Local transport Host-provided native-pipe bridge to a Unix-domain socket; framed JSON-RPC with version negotiation, deadlines and turn metadata Direct distributed-JS inspection; no password/token in the inspected request envelope
Native caller identity Socket admission reads OS peer audit token, checks signing publisher, then parent/relay ancestry; live Python connections close before request bytes Predicate reconstructed from pinned native binary; bounded live rejection, not comprehensive isolation
Runtime topology Ordinary worker uses named RPC; trusted service worker uses native bridge; socket peer is the native supervisor Embedded-JS review and owned-endpoint live test; production sandbox not audited
Admission limit Signed Node with an ordinary parent fails; signed Node with another signed Node parent receives a version reply Repeated with a detached controller under launchd; that detached arrangement was not tested for desktop actions
App approval JS obtains app policy and requests host approval with session/always persistence Source-reviewed; official docs describe saved per-app approval separately from OS consent
External MCP host Installed launcher exposes persistent JavaScript with app bindings, semantic diffs and app approvals; TextEdit input verified from a saved file Existing Mac consent/configuration reused; YA integration and fresh installation not tested
Open-source integration Codex includes feature/configuration, app policy and MCP integration Native Sky transport/authentication implementation was not located in the inspected Rust checkout

Current, initial discovery phase: After the initial static review, the supported CUA inventory call started the service. Its executable matched the inspected artifact. The socket and parent directory were current-user-owned, mode 0600 and 0700. Native app discovery passed before and after raw Python/signed-Node probes were disconnected. A zero-byte connection also closed immediately, and service logs reported sender authentication failure. No capture, input, app approval or permission change was requested. The spike owns process-tree, framing and cleanup detail; private inventory and raw logs are not retained.

Process and protocol map

Current, reconstructed from source and bounded live tests:

MCP host: Codex integration OR our temporary Python test client
  | MCP JSON-RPC over child stdin/stdout; approvals return over this channel
  v
Signed bundled Node running the real @oai/cua-repl launcher
  v
Signed native node_repl supervisor
  |-- ordinary Node worker: agent JS / cua app handles
  |       | named RPC via supervisor
  |       v
  |-- trusted Node worker: configured @oai/sky/service handler
  |       | native-pipe connect/write/close messages to supervisor
  |       v
  +-- native broker opens Unix socket (OS sees supervisor as peer)
          |
          v
      Genuine SkyComputerUseService (separately launched application)
          |-- kernel peer identity + signing/parent admission
          |-- native app-policy and desktop-operation handling
          +-- Codex app-server subprocess dependency

      macOS Accessibility / Screen Recording permissions underpin service use

The service normally appeared under launchd; it is not necessarily a child of the MCP runtime. Its app-server subprocess is distinct from any app-server that the host uses to coordinate its agent. The diagram shows observed components and communication, not a complete internal service call graph. “Broker” here names the runtime's native socket bridge, not a demonstrated standalone authorization daemon or backend token issuer.

There are three different interfaces: MCP exposes tools such as js and js_reset; the persistent JavaScript API exposes cua app handles and semantic observations; the trusted implementation sends private framed requests to Sky. A skill or lazily emitted API documentation teaches tool use; it supplies no OS permission or session authority. The protocol and launch record owns exact tool names and installation discovery, and the transport record owns framing and startup details.

Reconstructed admission boundary

Current, static native review: the normal path is JS tool → native runtime broker → Unix socket → service admission. The broker is a runtime component; its Mac connect routine opens the socket directly. An owned-endpoint probe confirmed the OS-reported socket peer is the native node_repl supervisor, not the trusted JavaScript worker. A separate per-connection helper was not found in that routine.

The service obtains peer identity from the OS rather than trusting a PID or session name in request JSON. It first checks the peer's signing publisher. It then requires a trusted immediate parent, or an allowed signed Node relay parent with a trusted ancestor. The bounded ancestor walk has an eight-parent limit. An explicit alternate integration is also recognized. The spike records the requirement initializers, branch interpretation and exact binary anchors. A signed interpreter with an ordinary shell parent does not meet these rules merely because Codex appears farther up its process tree.

Current: no short-lived client token exchange was found in that admission flow. The macOS audit token is OS-provided process identity, not a bearer secret sent by the agent. Per-app approval and OS Accessibility/Screen Recording permissions remain separate layers.

Open: signing-information comparisons were traced, but a SecCodeCheckValidity call was not found in the inspected path. Do not equate that with a proved signature-validity policy or infer a bypass. Full protection against process replacement, PID races, cached identity, misuse of the trusted runtime, other transports and a hostile same-user shell remains unverified. Neither the inspected admission routine nor live discovery establishes session-specific cryptographic authority or revocation behavior.

Lock-screen authorization boundary

Current (2026-10-14), source-reviewed, static only: installed bundle version 26.1005.1001425 (build 1001425, alongside JavaScript package directory 26.1007.71326) contains an optional SecurityAgent authorization plug-in that adds a password-free alternative to system.login.screensaver. The component was not installed or invoked on the inspected Mac. Targeted ARM64 disassembly found that the plug-in connects to the service's fixed lock-authorization Unix socket, obtains the peer audit token, compares the peer's OpenAI Team ID and service signing identifier, and returns allow only when the reply starts with ALLOW. No account password is stored or entered by this route.

The inspected plug-in path calls SecTaskCopySigningIdentifier and SecTaskCopyTeamIdentifier, but no call to SecCodeCheckValidity, a designated requirement check, or an exact installed-artifact hash check was found. This is a security-boundary gap: the password-bypassing mechanism relies on publisher and identifier metadata without an independently observed strict validation of the live peer's code. It is not a demonstrated unlock exploit. Hardened-runtime enforcement or another unobserved OS constraint may narrow practical attacks, and the component was not dynamically tested. The separate signed-Node ancestry result concerns ordinary service admission; it must not be combined with this static finding to claim that the detached probe could unlock the Mac.

The broader locked-use design includes meaningful safeguards: an active Computer Use attempt, a separate guardian, display covers, physical-input detection, per-thread leases, and relock on input or completion. Static review did not establish the exact cover-before-unlock ordering, service-side authentication of the plug-in connection, capture exclusion, attempt limits, or failure behavior across fast-user switching and FileVault boundaries.

Decision input: Machine Control's protected unlock broker must retain strict live-code validation and the installer-pinned exact CDHash, rather than trusting a publisher-wide identifier. Its unlock mechanism also requires an atomically consumed one-use grant bound to the locked console identity, boot, broker generation, live peer and monotonic expiry. The macOS locked-use topic owns those decisions and their independently qualified limitations.

Runtime and launch provenance

Current, source-reviewed / bounded live-tested: the host launches the native runtime through inherited MCP stdio and configures named trusted services. Submitted JavaScript runs in an ordinary worker with named RPC, while a separate trusted worker loads configured handlers and receives the native bridge. File imports are restricted to canonical configured roots. A temporary standalone MCP client could select an owned handler and prove the bridge's socket owner without credentials or a production agent session. This measures host-configured service loading, not control of an existing session; production sandbox settings and all alternate ingress routes remain unreviewed.

Current, bounded live-tested: the publisher/parent rule has a concrete limit. An owned script running in the bundled signed Node was rejected when launched by Python. Adding a signed Node parent running an owned launcher produced a valid service version reply. The same negative/positive pair held with the Python controller detached under launchd, without a Codex/ChatGPT ancestor in its ordinary process tree. This matches the reconstructed default trusted-parent publisher rule. Responsible-process attribution was not tested.

This uses authentic executable identities; it is not signature forgery. It also shows that this socket admission check does not establish an official Codex session or the provenance of interpreted scripts. Only version pings were sent in that ancestry experiment. The subsequent external-host test below uses the normal policy wrapper; direct-native app-policy bypass and full same-user isolation remain untested. No backend-issued session token was needed for these replies. The spike owns exact process topology, artifact pins, probe method and cleanup.

Approval and configuration ownership

Current: these layers must be described separately. A successful check at one layer does not establish the properties of the others.

Layer Owner / observed mechanism What it does not establish
Tool availability Host/plugin selects launcher, enabled surfaces, modules and tool instructions Installation, OS consent or authority for the agent
Socket admission Native service uses kernel peer identity and reconstructed signing/parent checks Official agent-session origin or provenance of interpreted scripts
App eligibility Sky wrapper asks the native service for app policy; handles allowed, denied and forbidden results An allowed result is not itself evidence of a human approval or saved Always allow decision
App approval Wrapper requests MCP host elicitation; host may ask the user or resolve saved consent An accept response does not attest that a person clicked a trusted native dialog
OS consent macOS permissions associated with the service's identity Each upstream caller having separately obtained user consent
Continuing authority / Stop Product behavior requires separate lifecycle investigation Connection admission and one successful action do not prove revocation or per-operation revalidation

Current, source-reviewed: the wrapper first obtains policy, rejects denied or forbidden apps, then requests host approval even for an eligible app. Its metadata identifies the Computer Use connector, app, tool and risk level, and offers session or session/always persistence according to native policy. Only an accept result permits the wrapped operation. It recognizes a persisted-state response marker; recognition does not locate the underlying storage. The detailed approval trace records source paths, fields and the inspected configuration schema.

Current, experiment ownership: we wrote a temporary MCP client/host, not a mock MCP server or replacement Sky service. It launched the installed OpenAI MCP implementation and answered its approval requests. The rule “accept only Computer Use requests for TextEdit” lived in that Python client. It was our task-specific allowlist, not a new Sky setting. All 22 elicitation requests matched it; no persistent Always allow setting was written. The real service still supplied app policy, admission and desktop operations.

Upstream-claimed: official documentation describes per-app approval and Settings -> Computer use management of Always-allowed apps, separately from macOS OS permissions. This describes normal product UI, not a UI exercised in the external-host experiment.

Current / Open: the pinned open-source Codex schema supports computer_use.default_app_access and computer_use.macos.bundle_ids allow/deny requirements. Source tests demonstrate parsing/round-tripping, not complete native enforcement. We have not located or verified the macOS persistent host-approval backing store, its precedence against every policy source, or every service-side operation check. Do not call these app-policy keys the Always-allowed-apps store or import a Windows-specific setting into macOS.

Inference: host elicitation is not an independent human-presence boundary against a host that can supply its own acceptance. Native caller admission and any service-side authorization must carry that part of the threat model. No separate interactive native arming step appeared in the successful test; it reused existing OS/account/configuration state. This does not prove that first installation or every product mode lacks such a step. We did not test direct-native bypass of the wrapper or determine all native app restrictions.

MCP surface and external use

Current, source-reviewed / bounded live-tested: the installed @oai/cua-repl launcher wraps native node_repl as a stdio MCP server. Its model-facing js tool starts a persistent environment containing cua. App bindings expose state, screenshots, semantic clicks, typing, keys and value setting; Mac state uses indexed accessibility text and subsequent diffs. Bootstrap and first-use documentation teach this interface. A legacy Sky skill is not the same API and does not supply runtime installation or permission.

Current: installation is a component set, not just one service executable. The desktop app contains signed Node, native runtime, module packages, launcher, Sky service and a Codex CLI. The Codex home has a native-service copy and cached plugin launch configuration in the inspected installation. Runtime-state folder existence alone is not executable discovery. Version-specific locations and hashes belong to the linked experiment. The native service may need a working Codex app-server subprocess in addition to existing OS consent and host approval.

Current, bounded live-tested: an independent temporary MCP host accepted only the user-authorized TextEdit app elicitation. Default service startup failed because its Codex app-server exited; the built-in CUA tool failed the same way. An owned service instance with an explicit installed Codex CLI path and private socket passed the ordinary policy/approval workflow. It exposed TextEdit state, operated File -> New, typed a marker and saved a test document. An independent file conversion verified the exact text. The owned document was closed and removed, prior formatting restored, and owned runtime/service processes reaped. No MC runtime or YA agent session participated in that route.

Current, limits: one shortcut produced a formatting change instead of New; menu actions provided the observed New effect. The Save As name field treated a path as a literal filename; the actual owned file was verified and cleaned up. These are useful reasons to retain independent effect checks. App menus were observed and operated; system-wide menu coverage and keyboard-layout fidelity were not established. Screenshot fidelity, native approval-bypass resistance, revocation, fresh installation and model-performance comparisons remain untested.

Open: the reviewed YA Codex adapter has no explicit MCP elicitation-request handler. End-to-end integration must test app consent, decline/cancel, persistence, tool and image output, lifecycle hooks and cleanup. The working external host is feasibility evidence, not a completed YA feature or a promise that the proprietary interface is stable or supported for third-party use.

Agent-facing mechanics and a signed-out guest (2026-10-14)

Current, bounded live-tested: in a dedicated macOS 26.6 experiment guest, Codex Computer Use worked without a ChatGPT sign-in while Codex's model traffic used a router-provided provider. It needed the desktop app's installed component set copied from a matching installation, the desktop app running (signed out was enough; without it the runtime's launch request for the native service failed), and Accessibility plus Screen Recording for the service. getState, accessibility trees and screenshots then worked, and the same image's isolated clones inherited the setup (Tactical 119).

Current, source-reviewed: the model-facing js tool is a persistent REPL with top-level await; bindings such as an app handle survive between calls until js_reset. A bootstrap import installs cua, whose app and browser-tab handles share one target API (getAXState, getScreenshot, click by element number or coordinates, setValue, scroll, drag, key, type and paste). The JavaScript side reaches the native service through a trusted in-runtime service over a length-prefixed JSON-RPC Unix socket with a handful of request types. Mac trees are indented text lines with small integer element numbers; after the first read the native service returns diffs (~ changed, + added, removed numbers summarized as ranges) or a one-line no-change sentinel. Numbers are reused across reads. Screenshots are attached inline. User interference surfaces as a typed, retryable "user changed the app" error. The bundled guidance tells the model to batch an action with the next observation, avoid sleeps, prefer element numbers, and verify visible results.

Current, measured on one task (three runs; caveats below): Computer Use calls took about 1 s each with 1–5 k-character diffs; Machine Control CLI calls took about 2.5 s, of which roughly 1–2 s was CLI, adapter and claim overhead rather than resident work, and a full desktop snapshot was about 140 KB of JSON. Computer Use addressed elements by number; the Machine Control run relied on coordinates and window captures retrieved in separate steps. Both Computer Use runs failed in the native Open panel; the Machine Control run succeeded. The runs used different probe folders and agent wrappers, so this is a qualitative interface comparison, not a success-rate result. Unified desktop client records the resulting persistent-interface experiment.

Current: research/vendor/extract-sky-reference.py copies the installed JavaScript packages (minified JavaScript, about 350 TypeScript declaration files and the bundled Markdown API and instruction documents) and the cached Computer Use and browser plugins into a Git-ignored local folder, with a manifest of versions, signing team and hashes. The JavaScript is minified but not obfuscated, and ships without source maps.

Current, source-reviewed (local reference): platform clients differ underneath one model-facing API. The macOS client keys calls by application and alone supports diffs, paste with clipboard restore and text selection; the Windows client keys calls by window and can return several screenshot regions for transient UI; the Linux client renders AT-SPI trees with pruning and static-text merging and keeps element numbers stable per native identity across reads. Actions return nothing and the model is taught to batch an observation; observation calls settle internally. Errors carry codes whose messages tell the model what to do next (re-read after user interference, stop after a user stop, call again while permissions are pending). A physical Escape on Windows rejects the rest of the turn. Machine Control's draft session API, which adapts these ideas to its claim, grant and delivery-effect contract, is in Tactical 123.

Current, static review of the native components (symbols, metadata, imports, strings; a few functions disassembled; nothing executed): the service is an unsandboxed Swift background app. A lock-screen guardian runs the same code as a separate process, and a native MCP client reaches the service over XPC. Private system functions are resolved at runtime rather than linked, so the binary does not name its private dependencies. Detailed private notes stay with the local reference; security-relevant details are deliberately not reproduced here.

  • Accessibility: attributes are read in batches per element, with an optional whole-subtree prefetch that can be disabled per application, and trees are cached and invalidated from accessibility notifications. A sequence of named clean-up passes prunes, merges and flattens the tree (rich text becomes Markdown); long lists and text are cut to the visible range with a note. Element numbers carry over between reads for the same underlying element; diffs are structural with a line budget. Chromium and Electron apps are switched into full accessibility mode.
  • Capture: the target window together with its attached sheets, menus and popovers, as JPEG or PNG; no set-of-marks drawing and no OCR, Vision or bundled models were found.
  • Input: mouse events are addressed to the target window and posted to its process, so the user's real cursor does not move; a separate overlay draws a virtual cursor, and focus guards keep the target from taking key focus. Key names follow X keysym conventions mapped through the current keyboard layout. A lazy pasteboard reveals when the target actually reads a paste.
  • User detection: event monitoring distinguishes the service's own synthetic events from the person's, raising a debounced "re-read" error. There is no global stop hotkey; stop is in the desktop app's UI.
  • Session UI: an animated lens and cursor, and a live picture-in-picture stream of a backgrounded app.
  • Locked use (optional, not installed on the inspected Mac): an authorization plug-in lets the service approve unlocks for an active session without storing a password; a guardian draws a privacy curtain and relocks on any physical input, pausing automatic unlock until the person unlocks.

Open: which private functions are resolved, numeric budgets and capture defaults, when element clicks use accessibility actions versus synthetic events, and how well window-addressed events work in Catalyst, Electron and games. These need dynamic study.

Deterministic native behavior study (2026-10-14)

Current, bounded live-tested: an original AppKit target and a separate sentinel app were exercised in one disposable ARM64 macOS guest. Five repeats per case compared the genuine installed Computer Use MCP/runtime with MC's claimed common CLI. This qualifies the fixture behavior, not other app families, physical Macs, protected desktops or a supported third-party Sky integration. Tactical 124 owns the execution record; the original probe corpus is reusable.

  • Sky increment, pointer-only surface, text entry, sheet open/close and menu item effects passed 5/5 each. The foreground sentinel retained key focus, unchanged text and cursor position, with no recorded foreground/cursor disturbance. The oracle samples at 20 ms; shorter transients remain unproved.
  • The fixture's accessibility callback recorded semantic presses for ordinary buttons. Its pointer-only surface instead recorded mouse-down/up events. This dynamically distinguishes routes without inferring them from acceptance.
  • With 20/100/300 static rows, unchanged Sky reads had median MCP round trips of 47/48/73 ms and 414 serialized result bytes. Adjacent static text was merged; subsequent unchanged reads returned a no-change message. These are warmed reads, not cold-start or model-token measurements.
  • After fixture actions, observations took roughly 420 ms for delayed, burst and continuous updates. They included the completed delayed/burst changes, but returned revision 13 while the continuous producer was headed to 100. External timer changes without a preceding Sky action returned much sooner. Inference: settling is action-sensitive and bounded in this workload; the measurements do not establish its exact algorithm or a completion fence.

Current, sampled native evidence: active read stacks contained AXUIElementCopyMultipleAttributeValues, AXUIElementCopyHierarchy, individual attribute reads and action-description queries. Press/read stacks also contained AXUIElementPerformAction. Unchanged rendered output therefore did not mean all native accessibility work was skipped. This supports the static batch/prefetch findings while leaving cache hit rates and invalidation rules open. Stack samples are not API call counts, and absent samples prove nothing about an API's use.

Current, instrumentation limits: scoped syscall counts and native stack sampling worked. User-space DTrace API probes reported invalid-user-access errors despite exit zero; their counts are invalid, including a retry with literal counter labels. Instruments xctrace was unavailable. The prepared base already had SIP disabled; the study changed no protection or entitlement. Do not generalize attachment capability to a protected physical installation. Initial pointer profiling also exposed a changing text-field label; that invalid workload was excluded and rerun with fail-fast error checks.

Decision: borrow the measured ergonomics through original MC code. Prioritize compact observations and retained claimed dispatch, then qualify background pointer/text routes. Preserve effect predicates and bounded observation deadlines rather than treating notification quietness as task completion. Exact pins and methods are in the private spike study; raw trace records remain in the private local evidence store.

Observed security posture

Each row is a separate evidence claim. In particular, do not combine the detached ping result with the non-detached TextEdit result and report a detached hostile client controlling arbitrary applications.

Caller / test Strongest observed result Boundary of the result
Ordinary Python or bundled signed Node directly below the agent shell Connection closed before a reply; zero-byte probe closed before parsing; authentication failure logged Negative admission examples, not proof that every same-user process is excluded
Temporary runtime with owned trusted module and owned endpoint Ordinary worker lacked native bridge; trusted worker had it; kernel-reported peer was supervisor Host-configured bridge placement; no Sky desktop request, no production sandbox acceptance
Signed Node client with a signed Node parent, both running owned scripts Real Sky version reply; repeated below detached controller with parent PID 1 Authentic executable chain, no signature forgery; version only, no detached desktop-action test
External MCP host with genuine launcher, real user home and TextEdit-only approval responses App state, menus, typing and saved text verified independently Existing installation and consent; not detached, fresh-install, multi-app, native-policy-bypass or YA end-to-end evidence
macOS service executable strict signature check Passed for inspected executable Separate inspection from admission reconstruction; not proof the service itself calls the same validity check

Current: socket and directory modes exclude ordinary other-user filesystem access in the observed configuration, but do not separate programs running as the owner. Additional native identity checks explain the rejected callers. Publisher trust of a generic interpreter still permits scripts authored by someone other than that publisher; the successful chain demonstrates this limitation without modifying any signed binary.

Open: no test established resistance to a malicious unrestricted same-user shell, administrator, module/configuration substitution, broker misuse, stale sender context, PID reuse/reparenting, or alternate Apple-event/XPC/protected routes. No reviewed code path or test establishes session-bound cryptographic authority, lease expiry, Stop/revocation semantics, or all-route scope checks. The absence of a bearer credential in the inspected local envelope does not prove the product never uses account authentication, cryptography or backend policy elsewhere. The TextEdit test reused existing account state.

Current, locked-use footprint (read-only local observation, macOS 27.0): an installed Codex Computer Use adds /Library/Security/SecurityAgentPlugins/CodexComputerUseAuthorizationPlugin.bundle and joins system.login.screensaver as com.openai.sky.CUAService.AuthorizationPlugin.remote ahead of use-login-window-ui with k-of-n = 1. Any other locked-use provider must therefore share that rule rather than assume the stock shape; see Tactical 106. How the product's own removal edits the rule was not observed.

Current, capability limits: app menus worked, and typed text persisted. One shortcut instead changed formatting; an absolute path in a save-name field became a literal filename. API acceptance alone would have hidden both differences. Screenshot fidelity, exact-window confinement, protected/system UI restrictions, locked-session operation, background-input non-interference and remote use were not qualified. Neither this record nor a product safety restriction establishes why OpenAI chose its architecture. No vendor-confirmed vulnerability or comprehensive security audit is claimed.

Sources and investigation methods

The spike's exact inputs and additional pins identify versions, source revisions, relative installation paths and SHA-256 hashes. Binary addresses apply only to those ARM64 artifacts. Readable bundled JavaScript, native reconstruction, open-source code, product documentation and experiments are different sources of evidence.

Question Source and how inspected Detailed record
Installation and provenance Package/plugin manifests, README, MCP template, selected launch fields and app archive; hashes and codesign inspection Inputs/discovery
Native wire protocol and service startup Distributed targets/mac/native-pipe.js, client and service facade; bounded source searches Transport
Admission predicate strings, nm, Swift metadata/demangling, bounded ARM64 disassembly and requirement initializers; not source access to the native service Control-flow and addresses
Lock-screen authorization Pinned installed native bundle; codesign, otool, nm, strings, metadata and targeted ARM64 disassembly; component neither installed nor executed Sanitized synthesis in Lock-screen authorization boundary; detailed proprietary extraction notes remain local and untracked
Runtime authority placement Launcher and embedded runtime JS; owned handler/endpoint fixture with kernel LOCAL_PEERPID Runtime topology
Real rejection and acceptance Process trees, socket ownership/modes, lsof, scoped service logs, bounded framed probes and detached negative/positive pairs Initial probes, signed-parent experiment
App policy versus approval Distributed computer-use-policy.js; pinned Codex configuration schema/tests; official product documentation Approval trace
App-server dependency and actual effects Native locator reconstruction, service error/log, direct CLI initialize control, genuine external MCP client, fresh AX state and textutil file oracle External experiment
Codex/YA host integration Pinned open-source stdio transport, app-server request schema and YA provider request handler Host path, YA gap

Current, retention limits: records retain sanitized methods, results, pins and native anchors. Private paths, raw UI/log output, transient scripts, proprietary extracts and owned test documents were removed. The early authorization and external-host experiments have no retained reproduction harness or raw trace from which to re-audit every observation. The later native-efficiency study has an original checked-in probe corpus and private raw profiles; it does not retroactively strengthen the authorization findings. Neither is a replayable security certification. The owned MC identity fixture is separate evidence and must not be reported as a Sky test.

Current, documentation consolidation: on 2026-10-04 the transport and approval-wrapper hashes were rechecked against the recorded pins, and the Codex schema/test source was reread at the recorded revision. No new service launch, UI operation, permission change or security probe was run for this documentation pass. Official product claims above were consulted during the 2026-10-03 investigation and are not a fresh product-version qualification.

Agent confirmation behavior in the capability baseline

Current, live workflow evidence: three pinned Sol/Computer Use extension trials differed in adherence to delivered confirmation instructions. The first stopped before unpacked installation for action-time confirmation. The second and third installed the extension without that confirmation and passed independent enabled-registration and page-behavior checks. All received the relevant requirement. This establishes observed model-behavior variation, not a native API incapability or a test of native caller authorization. An effect pass alone must not become a claim of compliant unattended completion. Tactical 125 owns the comparison and separate policy annotation; exact transcripts stay private.

Fit and next evidence

Other-model bridges (2026-10-15)

Current, source/documents reviewed: public external-agent integrations exist. They are not all the same route:

  • songkeys/claude-codex-computer-use is an MIT bridge to the installed native MCP client, using a signed Codex launcher without a Codex reasoning model. Its reviewed adapter automatically accepts elicitation and recycles after idle/user-stop results. Those policies are not adopted by MC's bounded fixture experiment.
  • promptadvisers/claude-mods-computer-use-threads declares MIT and documents direct tool use, per-app approval choices and caller leases through a mod-enabled Claude runtime. Its integration is not established for YA by those upstream claims.
  • leeguooooo/computer-use now documents an archived MIT broker rewrite that delegates whole tasks to a Codex model. Its earlier patch/hook approach was removed. This is distinct from Opus choosing every action and receiving each state/image.

The spike review owns exact pins and review depth. No third-party bridge or proprietary asset was installed or adopted.

Current, bounded live-tested: YA-hosted Opus 5.5 at medium/normal directly completed TextEdit save and menu/conversion through the genuine installed unified runtime. Both workflows returned two distinct inline screenshots, passed independent file oracles and explicitly closed the child runtime. All 37 app-approval elicitations identified the authorized TextEdit bundle; the host answered from that exact experiment scope, without saved Always allow. The adapter launched no Codex reasoning session. Two earlier startup failures exposed an optional Claude discovery request that must not kill MCP handshake; they remain retained. Tactical 127 owns methods, costs, cleanup and the setup recipe. General approval UI, live denied-app/physical-stop behavior, other apps and runtime versions remain unqualified. These are feasibility results, separate from the frozen performance comparison and not broad YA product support.

Decision: Use the separation between native caller authentication, app-specific consent and agent tool advertisement as a design benchmark. Machine Control must retain an agent-neutral interface and authenticated local/remote access; an OpenAI-only identity policy would not satisfy that goal. Caller authorization owns the high-priority design investigation.

Open: In an isolated authorized test environment, independently test the remaining admission branches, production sandbox configuration, post-admission desktop authorization, reconnect, process replacement and revocation. Audit the trusted bridge as a potential confused deputy and establish whether native authorization is bound to a session. Fresh-install and full platform-action conformance remain open beyond the bounded TextEdit workflow. Provider landscape owns optional-provider and model-interface direction.

Decision: carry forward OS-derived native identity, a narrow broker API, separate app consent and explicit lifecycle ownership as useful patterns. Require MC's own evidence for exact broker identity, authenticated upstream session origin, per-operation scopes and Stop/revocation; do not substitute a publisher-wide interpreter rule or self-asserted MCP acceptance. This is design input, not a statement of MC's implementation status; the owning topic tracks that independently. An optional Sky route must not silently bypass an MC denial or Stop.

Open, next investigation order:

  1. Trace macOS policy and persisted approval ownership through the native service/app-server/host boundary, including decline, cancel and withdrawal.
  2. In a dedicated authorized environment, qualify native per-operation checks independently of the JS wrapper and distinguish app scope from window scope.
  3. Audit broker ingress, loader/config integrity, production sandboxing and process-lifetime/revocation behavior against explicit negative cases.
  4. Exercise clean installation, account/OS consent, component discovery and YA elicitation/lifecycle handling before describing a usable YA provider.

For future work, first match artifact hashes and source revisions, resolve the selected installation rather than guessing a cache path, and decide which specific unknown the experiment tests. Preserve positive and negative controls, bounded deadlines, an independent effect oracle and ownership-based cleanup. Record changed evidence in the spike and update this synthesis; do not silently promote a result from one host, route or consent state to another.