AI Stack OS
This is the AI stack I've evolved through eighteen months of daily commercial use. Not theory — daily practice. The chart above shows the architecture; what follows is what each layer actually does, why each tool is in the position it is, and what I've learned about respecting their distinct distortion signatures.
The colours and indentation below match the chart. Read top to bottom for the full architecture, or jump to any colour for one layer.
Tier 1 is where I think. Three reasoning partners, each operating in a distinct register. One note before I describe them: I instructed all three with the exact same description of communication style and persona, word for word. The differences below are not configurations I imposed. They are signatures the models produced from identical inputs.
I treat Claude as a 45-year-old peer with depth — the register I reach for when commercial reasoning needs to hold under pressure, when documents have to land in operator hands without being dismissed, when I need a thinking partner who fits inside professional environments without sentimental drift. ChatGPT operates as something different — a deeper psychological layer, useful for behavioural framing, dream work, longitudinal observation across months. Gemini is closer to a new college graduate: fresh data, full energy, can-do attitude, but lacking the wisdom that arrives through more years. I love the energy, but I have to read its outputs against its tendency to overreach.
I don't pick between them. I triangulate. When Gemini's output needs ground-testing, I pass it through ChatGPT, which applies an experienced-person filter and surfaces premature hypotheses. When ChatGPT's output feels too cautious for a commercial context, I pass it through Gemini, which adds the commercial edge ChatGPT softens. When Claude's commercial reasoning needs differentiation-testing, I run it past ChatGPT — which often tries to revert the prose back to its own predictable style. That tendency tells me my Claude draft is doing real differentiation work.
Each of these models has a distortion signature I've learned through repetition. Recognising the distortions is what makes them useful. Treating their outputs as truth is what makes them dangerous.
Tier 2 is where I find things. Three tools, each with a narrow edge that none of the others can match.
Perplexity is my citation engine. When I need real sources with verifiable origins — industry reports, earnings calls, regulatory filings — I go to Perplexity first. Not for reasoning; for grounded retrieval. NotebookLM does something different: it synthesises across a corpus I upload. Multiple PDFs, handwritten notes, scattered documents from a discrete period of work — NotebookLM holds them together and produces structured outputs that no single-thread chat could. Grok occupies the smallest but most specific slot. It is the only tool with native access to current X conversation, which matters perhaps four times a year when something is trending in real time and the signal needs to be read before the noise dominates the circles.
Gemini also lives in this layer in one specific capacity: native YouTube content access. If I need detailed extraction from a video — a particular argument, a specific timestamp, a structural summary — Gemini is the only reasoning partner that can engage the source directly. I switch modes for this use; it is not strategic work.
The principle of Tier 2 is the same as Tier 1: each tool has an edge that defines its role. Treating each of them as law set in stone wastes their distinct strengths.
Tier 3 is where work gets done. Three agents, each differentiated along three axes: access type, guardrail tolerance, and memory depth.
Claude in Chrome — what I call CiC — handles browser-based execution. Anything that lives inside a web interface, anything that needs a screenshot, anything that requires navigating a real website. Cowork operates on my filesystem directly: folders, directories, documents, version control. High token volume tasks that would otherwise burn my reasoning-partner context windows live here. Edward is the third agent, running on OpenClaw via Telegram with a self-authored constitution — three key constitutional documents I wrote myself, defining identity, operating ground, and resource discipline. Edward inherits flexible guardrails I wrote, deeper personal voice fidelity, and runs autonomous tasks while I am away from the desk.
The routing decision happens by task properties, not by tool preference. Sensitive personal context goes to Edward. High-volume non-sensitive filesystem work goes to Cowork. Browser-locked work goes to CiC.
Each agent has its own distortion signature I have learned through reps. CiC cannot push certain buttons, cannot upload or attach certain documents through web interfaces, and struggles with pixel-precise drag-and-drop work. Cowork honours strict identity guardrails to the point of refusing tasks that obviously belong to me: it once refused to reclassify the email archive of my father — an archive I had personally built, stored locally, and was entrusted with as the human backup layer — because our names differ. Edward, the most flexible of the three, has a tendency to reach confident conclusions roughly half the time inaccurately, paired with a warm, buddy-like emotional register. That combination is recognisable from Gemini's persona — the same energetic conviction without the wisdom to slow itself down. None of these agents are general-purpose. They are tools for specific operations, deployed deliberately.
Beyond these three core agents, I use specialist tools tactically: Canva AI for visual design work, Nano-banana 3.0 for image generation through Gemini. These are not part of daily orchestration. They are task-specific instruments I reach for when the work demands them, and they carry their own engagement-default behaviours that require active management.
Underneath the three tiers sits a layer I rarely see discussed in public AI writing: deliberate memory architecture. Tools have technical limits, and I have evolved practices around those limits over months.
ChatGPT, Claude, and Gemini all degrade over long conversation threads. ChatGPT acknowledges this and offers project folders; Gemini markets unlimited memory but in practice slows the same way. I work around all three by segmenting my use into named projects: career, physical health and nutrition, philosophy and dream work, legal counsel, real estate. Each project is its own world. Within projects, I name conversation threads by date for routine logs and by distinctive symbol pairs for psychological work — chapter 140 of my dream archive is named for the two cats and one dog from this past Saturday. I can recall any chapter by its symbolic anchor faster than any search function would return it.
Browser isolation is operator practice, not paranoia. Opera GX runs only ChatGPT. Safari runs only Gemini. Chrome runs everything else. No reasoning partner shares browser working memory with any other active task. Mobile apps outperform browser interfaces for high-volume voice work, which is why most of my stream-of-consciousness recording happens on the phone during walks. The trade-off: each platform has its own quirks. ChatGPT continues recording when not the active app and has the best transcription accuracy. Gemini also continues but caps voice at roughly five minutes. Claude stops recording when not the active app and has a known freeze at the ten-minute mark — a real bug I have hit repeatedly and which has cost me lost recordings.
Token economics is the second layer of memory architecture. Every time I plan a goal and its tasks, I estimate their token cost before assigning the work. Claude is the only one of the three reasoning partners that imposes daily and weekly hard limits — I hit both six or seven times before learning to upgrade to the Max tier rather than risk losing access at critical moments. Gemini and ChatGPT do not impose this kind of cap, but their reasoning does not cover all my regular tasks. The trade-off shapes routing: I paste long text directly into Claude — the file-upload cap is restrictive — while I attach more screenshots to Gemini and ChatGPT, where upload limits are not the bottleneck. None of this is theoretical. It is the cost calculation that decides which tool gets which task on any given day.
This is the layer that makes the rest of the stack viable across months of continuous use. Without it, everything degrades.
The Mac Mini M4 runs stationary execution work: Cowork, CiC, Edward. The 2017 MacBook Pro handles mobile reasoning chats — Claude, ChatGPT, Gemini in their browser or desktop interfaces. The Samsung Android phone carries Telegram for Edward and inbuilt voice recording across the three reasoning partners. Physical separation of layers matters. The Mac Mini connected to a Samsung monitor in early May was the upgrade that made high-volume desk work viable. Before that, the bottleneck was physical, not cognitive.
Every tool in this stack has a characteristic failure mode. Claude occasionally loses track of small contextual details — last week it confidently named Tuesday as today when today was Wednesday. Gemini suggests confidently from training data without checking current state — its recommendations during the early Edward setup cost me real money and a weekend before I learned to verify its technical claims independently. ChatGPT inserts unrequested stock images into outputs even when I explicitly instruct otherwise, repeatedly, in the same session. Canva AI follows the same pattern: I asked for icon size adjustments and it changed icons I had not asked it to touch, twice in one session. The pattern across all four is the same — each tool has built-in behaviours that quietly ignore what I told it to do, in favour of what its designers think users want.
The protection is cross-tool verification, not trusting any single tool. Last Friday, Claude assumed the URL parameter format I was using for tracking would work in Framer's analytics. CiC opened Framer, checked the actual interface, and surfaced that the format does not work — Framer only recognises standard utm_ parameters. The Claude blind spot was caught by a different agent looking at real evidence. This is the system working. No single node — including the human operator — has full coverage. The architecture earns its keep precisely when one part catches what another misses.
This is not a stack I would describe as finished. It evolves with use. The principle that has stabilised, though, is this: each tool has a temperament, each temperament has a strength and a distortion, and the operator's job is to keep both visible while the work moves forward.
The colour bands and indentation in this essay match the chart above. Read in sequence for the full architecture, or jump to any colour for a single layer.