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:
- Process and protocol map: what runs where.
- Approval and configuration ownership: where app policy, host decisions and OS consent differ.
- Native efficiency: independent effects, background interference, settling and bounded dynamic profiles.
- Observed security posture: measured cases and conclusions that must not be combined beyond their evidence.
- Sources and investigation methods: how to trace each claim to its inspected input or experiment.
- Fit and next evidence: implications for MC and unresolved work for future sessions.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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:
- Trace macOS policy and persisted approval ownership through the native service/app-server/host boundary, including decline, cancel and withdrawal.
- In a dedicated authorized environment, qualify native per-operation checks independently of the JS wrapper and distinguish app scope from window scope.
- Audit broker ingress, loader/config integrity, production sandboxing and process-lifetime/revocation behavior against explicit negative cases.
- 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.