# I Wanted Control from Gemini Desktop. I Got More Mystery. Published: 2026-11-21 Author: Alexander Conroy Categories: Technology Tags: cloud, google, programming, Technology Description: I wanted Gemini Desktop to understand the environment I already built. Instead, I found fragmented capabilities and another context system to manage. Exporting your data is not the same as keeping it accessible to the tools you choose. --- I downloaded Google's Gemini desktop app for macOS because I thought I could finally use my phone to dispatch useful work across my machines without rebuilding my agent workflow around another application. That expectation lasted about ten minutes. Understanding what I had actually installed took considerably longer. I use Antigravity CLI (`agy`), Claude Code, Codex, Kimi, and Grok CLI across Macs, Windows machines, and a headless Linux development server. My environment extends well beyond the computer in front of me. I maintain shared global context through my business tooling, including Chiron and `ecli`, and my personal Triúr tooling, alongside repository instructions, skills, custom agents, and a session aggregator. There is work behind that arrangement. Its value is that I can change harnesses without explaining my entire working environment again. When Gemini advertised local computer use and phone-to-computer tasks, I pictured a useful front end: select a machine, dispatch a task, and have the agent work with the context already there. Instead, I found several overlapping interfaces with different rules for context, remote access, settings, and conversation history. There is a useful ending to this investigation: **we are keeping `agy` and using Antigravity's browser Remote Control as our remote front end.** It is more capable than my first impression suggested. Gemini desktop and standalone Antigravity desktop do not earn a place in our workflow right now. Getting to that decision should not have required inspecting processes and databases. ## The Same Folder, Without the Same Understanding I started with my Obair repository in Gemini's Chat/Task experience. The agent did not read the repository instructions I expected it to discover. Obair is my operator-context repository. It explains where work belongs, how machines relate, and which tools carry which responsibilities. Its purpose is to let me begin from an established operational context. With my configured CLI harnesses, I can discuss the `ecli` Slack workflow, Triúr, the active machine, and the wider fleet without first explaining every name. That understanding exists because I deliberately maintain global context and repository discovery. I mean Grok CLI here, not Grokbot's hosted environment. The same conversation against the same folder in Gemini Chat/Task lacked that working knowledge. Connecting the directory had not connected the context system around it. The application could reach the work without inheriting the operating manual. This applies to the Chat/Task workflow I tested. It does not establish that every Gemini surface ignores instruction files. That distinction became central to everything that followed. Repository conventions are useful because they are ordinary. Instructions, skills, and agent definitions can travel with a Git clone. Different harnesses can read the same maintained source when configured to honor it. A different authorized agent can propose an edit and show me the diff. My scripts can synchronize global context without visiting a vendor dashboard first. I already maintain the bridges between harnesses. I wanted a desktop application to reduce that work, not introduce another context-management system. ## Antigravity Deserves Credit for Its Shared Context The Antigravity surface inside Gemini behaved differently. Later, the standalone Antigravity desktop app connected to my Linux development server and discovered shared context and skills there too. Google documents a shared customization layout for Antigravity App and CLI: personal resources under `~/.gemini/config/`, global instruction files, and repository instructions and `.agents/` directories. It also documents additional legacy skill locations read by the CLI but not the app. There is a real filesystem-based integration contract here. [Customization discovery](https://antigravity.google/docs/customization-discovery/) The desktop SSH session reported loading my company context, host instructions, and relevant skills. Its settings interface exposed discovered rules, skills, and token budgets. That deserves credit. Antigravity can participate in the local context system I maintain. There were also corrections needed on our side. On the Linux server, one independently maintained custom agent, `croi-operator`, was installed under `~/.gemini/agents/`. The documented shared location is `~/.gemini/config/agents/`. The desktop session reported that it did not discover that agent. This is a placement problem in our integration, not proof that Antigravity lacks custom-agent support. [Custom-agent documentation](https://antigravity.google/docs/subagents/) That agent also declared `view_file`, while the desktop session reported exposing `read_file`. We still need to validate the custom-agent tool mapping and its image-reading instructions. We have not demonstrated that the two names are interchangeable, or that the existing definition would fail. The general lesson is to validate definitions against the target runtime rather than assume that a shared Markdown format guarantees identical tool behavior. Another limitation appeared on my Mac: the installed rules documentation specified a 24,000-byte per-file limit, and the log showed my larger global rule being truncated. Discovery did not mean the entire instruction file was loaded. That host-specific finding should not be confused with the Linux session, which reported loading its smaller instruction set without truncation. Our synchronization tools need to target the documented shared locations, preserve each other's contributions, and check what actually loads. That work is manageable. It still does not make Gemini Chat/Tasks and Antigravity the same environment. ## Export Is Not the Same as Accessible Context “But you can export your data” does not answer my complaint about Gemini Chat/Tasks. Google documents uploading skills as files, folders, or ZIP archives and downloading them as ZIPs. Linked Drive files and notebooks are excluded from those downloads. These are useful capabilities. [Skills documentation](https://support.google.com/gemini/answer/17094296) But an account-managed skill is another object to maintain. An authorized harness can edit a shared local source file directly. I found no documented equivalent giving our tooling the same automated control over the operative skill in Gemini's account-managed library. That is not a claim that no API exists. It is a statement about the workflow established by the documentation we reviewed. Import and export do not automatically define which copy is authoritative, how edits propagate, or whether a project uses the skills committed alongside it. Session history has the same distinction. In the Chat/Task session, I could not find a way to get the conversation into my established workflow beyond copying and pasting it. Google provides [Takeout exports](https://support.google.com/gemini/answer/16920332?hl=en). Selecting data, requesting an archive, waiting for preparation, and downloading it is a batch export process. My session aggregator needs records as work happens. We did not establish an equivalent live local feed for Gemini Chat/Tasks, nor did we test whether an export reconstructs a complete resumable task environment. Google also provides an editable [memory summary](https://support.google.com/gemini/answer/18617127), while its [remote computer](https://support.google.com/gemini/answer/18789153) has persisted files, configuration, tools, and login state with separate lifecycle controls. Exporting a conversation is not necessarily exporting that working environment. This concern belongs to those account-managed workflows. The Antigravity histories we inspected were local files on our server. Their separation is a continuity problem; it is not evidence that those records are trapped in Google's cloud. ## Remote Control Turned Out to Mean Several Things Gemini's documented phone-to-Mac task handoff requires the same account, a running Mac app, and the same Wi-Fi network or a Bluetooth link. That is nearby-device integration. It did not establish the internet-wide access to my development machines that I had imagined. [Mac Tasks requirements](https://support.google.com/gemini/answer/17208717?hl=en) Antigravity offers a different route: [browser Remote Control](https://antigravity.google/docs/remote-control/) into an App or CLI instance running on your own machine. It also offers [desktop SSH connections](https://antigravity.google/docs/ssh/) to Linux hosts. Google's cloud agents are another execution environment again. My early impression that CLI Remote Control exposed only one session was incomplete. With the correct account, the website exposed our persistent Linux CLI daemon, multiple projects, existing conversations, a New Conversation control, and a remote folder picker. We successfully registered another existing project folder. That inspection did not test simultaneous execution of multiple new sessions, but it clearly showed more than a single forwarded conversation. The website also explained that Remote Control had moved into the sidebar while the main page focused on cloud-agent conversations. I initially found the navigation frustrating. Once we located the correct interface, it offered a much fuller experience than I had understood. This is the route we are choosing: `agy` on the execution host, with the website as a common front end from a laptop or phone browser. It preserves the relationship to the CLI environment we already use. We have not established an equivalent native mobile application experience, and selecting this route is not a claim that we completed a full phone usability test. The desktop app led somewhere else. ## Same Server, Separate Working Histories Standalone Antigravity 2.34.0 exposed an SSH Host menu populated from my SSH configuration. We did not find that option in the embedded Antigravity surface inside Gemini. Nearly identical interfaces offered different connection choices in our tests. Connecting to the Linux server initially sat at “Connecting,” but eventually succeeded. It opened another window and required another Google authorization. The separate window and remote sign-in are documented behavior. The projects looked familiar. Their conversations did not. The website showed my CLI history; the desktop showed “No conversations yet.” A read-only server inspection explained the split: | Connection | Runtime we found | Conversation store on the host | | --- | --- | --- | | Browser Remote Control | `agy remote-control serve` | `~/.gemini/antigravity-cli/conversations/` | | Desktop SSH | Separately installed Antigravity server | `~/.gemini/antigravity/conversations/` | We counted 509 CLI conversation databases. The desktop store was initially empty. After I created a desktop session, it contained one conversation database, and that session was absent from the CLI store. The sampled databases had matching conversation table definitions, but that does not prove their binary contents are interchangeable or that sharing or importing them is supported. Existing history had not disappeared. The two interfaces were using different stores. Standalone Gemini CLI had historically been installed on this server and its executable remained present. But the browser connection was served by `agy`. The agent initially confused these products when explaining its own environment, then corrected its explanation after inspection. Historical files did not identify the active backend. There was another wrinkle: the installed `agy` reported version 1.5.12, while the long-running CLI daemon was still executing a replaced older binary reporting 1.2.12. The desktop SSH server was version 2.34.0. Clicking Update in the web interface did not give us a clear account of what changed; the inspected daemon had not restarted. We did not establish the button's exact effect. I had set out to do development. I was now identifying running executable versions and comparing conversation directories. ### Updating the CLI Did Not Update the Running Daemon **If you use persistent CLI Remote Control, verify the running daemon after updating `agy`. Updating the executable on disk is not the same as restarting the process serving your browser.** After another CLI update on our Linux host, the installed binary reported 1.5.13, but the daemon still had the same process ID and September start time. Its running executable still reported 1.2.12. In this observed update, the daemon had not been restarted automatically. For our existing Linux user service, the explicit update-and-restart procedure is: ```bash agy update # After the update succeeds, and when active work can tolerate a restart: systemctl --user restart antigravity-cli-daemon.service agy remote-control status ``` A restart disconnects Remote Control and may interrupt work served by that daemon. Finish active work or arrange a suitable pause first. For the CLI-managed route across platforms, Google's documentation says re-running `agy remote-control start` restarts the daemon. The CLI also offers an explicit stop/start sequence: ```bash agy remote-control stop agy remote-control start --name "YOUR-INSTANCE-NAME" agy remote-control status ``` Replace the placeholder with your existing instance name, available from `agy remote-control status`. **`stop` unregisters the service; `start` registers and launches it again.** That is different from restarting the existing Linux unit in place. Preserve any intentional service-scope options rather than blindly changing how the daemon starts. [Daemon management documentation](https://antigravity.google/docs/remote-control/) When I actually ran the stop/start sequence, the commands reported success and `status` showed a fresh start time. But **neither the stop/start output nor the status output identified the running daemon version**. Status showed that the service was active, when it started, its instance name, and where to find logs. Meanwhile, `agy update` told me that CLI version 1.5.13 was already current. Those are different answers: “the installed CLI is current” and “the daemon is active” do not establish that the daemon is running the current version. The new timestamp confirmed a restart, but the command output left the version question unanswered. To answer it, we had to look below the product's own status interface. Verify the running process, not just `agy --version`, which checks the installed CLI. On this Linux setup: ```bash systemctl --user show antigravity-cli-daemon.service -p MainPID -p ActiveEnterTimestamp # Replace PID below with the MainPID reported above: readlink /proc/PID/exe /proc/PID/exe --version journalctl --user -u antigravity-cli-daemon.service -n 50 ``` Reconnect the browser afterward and check its status. We have not verified that a restart alone clears every “Update available” banner. Existing interactive CLI processes also need to be exited and relaunched, after preserving their work, to pick up the new executable. Codex has a similar separation in my experience: updating the CLI on a machine does not necessarily update its remote daemon. **But Codex lets me complete that daemon update from the Codex interface**, through the shared SSH remote session. I can finish the operation where I am already working. With Antigravity, the workflow we encountered sent me back to the terminal to update and restart the service, then omitted the running version from its status output. Both products have separate components. The user experiences are not equivalent. This is ordinary process lifecycle behavior underneath. The frustrating part is having to investigate it. An update control should tell me which component needs updating, let me complete the operation where practical, and show which version is actually running afterward. That is the integration and polish I expected. ## A Mac Client Does Not Mean a Mac Remote Host Trying the desktop SSH connection to Croí, my development Mac, produced an explicit `UNSUPPORTED_HOST` error. This feature requires Linux on the remote host. A Mac can run the client, but another Mac cannot be its SSH target through this route. Ordinary SSH into the Mac still works. We can run `agy` there through a terminal. Browser access through a configured CLI Remote Control instance is the route we intend to validate and use for the Macs we want available remotely. That distinction is easy to state now. It was not obvious while moving between Gemini's Remote Control setting, embedded Antigravity, standalone Antigravity, and the website. For our Linux development server, desktop SSH works, but it creates another runtime and history boundary. For personal development on our Macs, that desktop connection is unavailable. The browser-and-CLI route is the common model we are choosing instead. ## Shared Instructions Do Not Mean Shared Controls The configuration picture is partly unified. Shared projects and customizations coexist with CLI-specific preferences and desktop state. The CLI has its own `settings.json`. The desktop uses shared configuration plus its own state. In our tests, browser Remote Control deferred project settings to the CLI, while desktop SSH exposed project inspection and editing controls. A complete supported automation contract for every desktop preference was not established. That does not prove the UI is the only possible configuration method. It means we should not treat every internal JSON field as a stable integration API. The practical lesson is that shared `AGENTS.md` files and skills do not guarantee the same effective permissions, model selection, or execution behavior. We have not demonstrated a permission failure or security incident. We have established that those expectations require separate verification. ## Other Vendors Have Boundaries Too Google is not alone in putting different operating environments inside one product family. Claude's Chat/Cowork experience and Code have different roles. Claude Code desktop [shares CLI configuration with documented differences](https://code.claude.com/docs/en/desktop), while its [CLI Remote Control](https://code.claude.com/docs/en/remote-control) supports a server mode for multiple sessions without requiring the desktop app. I have not tested that mode in this investigation. OpenAI's [desktop arrangement](https://help.openai.com/en/articles/20001276-moving-to-the-new-chatgpt-desktop-app) puts Chat and Work alongside Codex, with separate Codex history. [Dot](https://help.openai.com/en/articles/20001530-getting-started-with-your-dot) introduces another agent environment with its own cloud computer and optional local access. It has controls, but its relationship to existing workflows is another thing users must learn. It gives me a similar feeling of opacity to Grokbot without establishing that their architectures are identical. Codex currently fits my remote workflow best: in my setup, I can reach the host's working environment and existing sessions without reconstructing where the work went. That is my experiential benchmark, not a claim that every competing feature has been exhaustively tested. OpenAI documents its [mobile remote workflow](https://developers.openai.com/blog/mastering-codex-remote-for-engineering). “Code” matters far beyond writing software. A CLI harness with the right tools and context can research, prepare documents, operate systems, and work with authorized communications. A simpler interface should make that power understandable rather than separate casual users from people willing to investigate the machinery. ## Windows Adds Another Uneven Boundary Google has a native Gemini Windows app. Its launch material advertises task delegation to Spark, while the reviewed general Tasks availability page and Connected Apps documentation did not provide a consistent platform picture. I cannot fairly turn that inconsistency into “Windows has no Tasks.” [Windows launch](https://blog.google/innovation-and-ai/products/gemini-app/gemini-app-now-on-windows/) · [Tasks help](https://support.google.com/gemini/answer/17094507) · [Connected Apps](https://support.google.com/gemini/table/17434654?hl=en) Mac has newly documented background computer use and a phone-to-Mac handoff. We did not establish equivalent Windows capabilities from the material reviewed. This is a documentation comparison, not a hands-on Windows test. [Mac computer-use announcement](https://blog.google/innovation-and-ai/products/gemini-app/computer-use-mac/) For a mixed fleet, these distinctions are the product. I need to know which machine can execute which work before designing a workflow around it. ## Standardization Is Part of a Premium Product Standardization has become a major theme for me this year because it makes agents useful beyond a demo. My tools need dependable answers about where instructions belong, what gets loaded, which settings win, and where work is recorded. Antigravity provides meaningful standards for part of that foundation. The criticism is that those shared conventions do not yet produce a coherent experience across all the interfaces we tested. And yes, this is a criticism of large organizations. More people, larger budgets, and more features do not automatically produce a premium product. A premium experience includes coherence. I should not have to inspect processes and databases to understand what connecting to my own server actually did. It makes me wonder whether different teams at Google have competing ideas about how an agentic harness should work, or whether inherited architectures are being joined together while releases keep moving. That is speculation about Google's organization. We have not established its internal reasons. We have established the investigation left to the customer. Constant shipping can push integration costs onto the end user. When an agent has broad access to machines and projects, unclear boundaries matter more than an awkward menu. A user may reasonably expect familiar instructions, permissions, execution locations, and records to carry across a familiar-looking interface. If they do not, the user may discover the difference only after work behaves unexpectedly. We did not demonstrate data loss or unauthorized actions. We demonstrated how much effort it took to understand the environment before trusting it with consequential work. Explain what an update updates. Explain when a connection starts another server. Make context and history boundaries visible. Publish supported configuration contracts that our tooling can maintain. Shipping a capability does not finish the job when the user must reverse-engineer how it fits. ## The Cloud Computer Moat Still Matters In [The Cloud Computer Moat](https://geilt.com/technology/the-cloud-computer-moat), I argued that the environment around a model can create deeper dependency than the model itself. Gemini's account-managed skills, memory, history, and remote computer state extend that concern. Export buttons help, but each separate management system adds work before another authorized tool can take over. Operational dependency can exist without a claim that Google legally owns my work. Antigravity's local files offer a materially different degree of control. I can inspect and back them up. Separate local histories remain inconvenient, but they should not be conflated with cloud-only custody. Local storage also does not make cloud inference private. Context sent to a hosted model still leaves the machine. The advantage of a maintained local workflow is control over the inputs, tools, configuration, and records. Consumer Gemini policies distinguish saved activity, training controls, and retention; disabling training does not eliminate all processing. Its separate computer state also has separate deletion controls. Workspace protections must not be assumed to apply to personal-account Tasks, and consumer Gemini terms must not silently be treated as Antigravity's terms. [Consumer Privacy Hub](https://support.google.com/gemini/answer/13594961?hl=en) · [Workspace privacy](https://knowledge.workspace.google.com/admin/generative-ai/generative-ai-in-google-workspace-privacy-hub) Google's own computer-use guidance discusses access to signed-in applications, visible sensitive information, shell execution through developer tools, and hostile instructions encountered in other applications. Those risks make clear operating boundaries more important. [Computer-use guidance](https://support.google.com/gemini/answer/18956635?hl=en) ## What We Are Actually Going to Use We are keeping `agy`. I like Gemini's models, and Antigravity's CLI remains useful in our work. The browser Remote Control interface deserves credit for exposing considerably more of that environment than I initially understood. Our plan is straightforward: - Use `agy` on the machine doing the work and browser Remote Control as our common remote front end, including from a phone browser. - Enable and verify CLI Remote Control on the devices we want discoverable. Keep installed and running versions aligned through controlled maintenance. - Manage the project settings that the web interface delegates to the CLI through the CLI workflow. Clean up project labels so the browser presents recognizable projects rather than an assortment of raw paths. - Make sure `ecli` and our personal context tooling publish their owned resources to the documented shared Antigravity locations. The Linux server does not run the Triúr toolkit; its independently maintained `croi-operator` definition needs its own placement and tool-mapping correction. - Remove Gemini desktop and standalone Antigravity desktop from our workflow. We do not need a second desktop runtime and history store for the work we have chosen to keep in the CLI. These are workflow decisions and planned cleanup, not claims that this investigation already changed installations, enabled services, or repaired the agent definition. We also are not merging active session databases or assuming a tool-name substitution is safe without validation. This gives us a workable route. It does not excuse the journey required to find it. I downloaded Gemini hoping for less machinery between an instruction and useful work. I am leaving with a clearer plan, continued respect for Antigravity's CLI capabilities, and considerably less enthusiasm for the desktop product story. I wanted more control. The first thing I got was more mystery. *Documentation and observations reviewed November 20, 2026. Testing covered Gemini on Mac, embedded Antigravity, standalone Antigravity desktop SSH, browser Remote Control, and read-only inspection of the Linux host. Agent reports about their own loaded context are attributed as such. No full Windows or phone usability test was performed; custom-agent compatibility and supported history interchange remain unresolved.* --- [Back to Index](/llms.txt)