Claude · PiniShv

I Don't Put All My Eggs in One Basket. Anthropic Is Making That Hard.

Mon, 13 Apr 2026 10:00:00 +0300

I’ve always believed in diversification. Don’t marry a single tool. Don’t build your entire workflow around one company’s product. Keep your options open, because today’s darling is tomorrow’s deprecation notice.

I still believe that. And this quarter, Anthropic proved exactly why—in both directions.

They shipped 120+ features in 90 days. Two flagship models. Computer use. Managed agents. A CLI. Connectors to 50+ workplace tools. The most aggressive product execution any AI company has shown. While OpenAI ships quarterly and Google on a similar cadence, Anthropic has been shipping weekly. Sometimes daily.

And then, on April 4, they cut off OpenClaw—the largest open-source AI agent project on GitHub—from using Claude subscriptions. Nine days later, OpenClaw announced they’d moved to GPT-5.4. “Anthropic cut us off. GPT-5.4 got better. We moved on.”

So now you dependent on OpenAI? 🫠 https://t.co/2jnzOlHXch
— Pini (@PiniShv) April 13, 2026

I don’t like putting all my eggs in one basket. But when one basket is riding a wave this big—and simultaneously proving why you shouldn’t trust any single basket—you need to understand what’s happening.

The numbers that matter
#

In 90 days, Anthropic released:

40+ Claude Code updates
15+ Cowork updates
20+ API changes
2 new models (Opus 4.6 and Sonnet 4.6)
Computer use, Dispatch, Connectors, Channels, Remote Control, and a Plugin Marketplace

Their internal team ships 60–100 releases per day. Anthropic engineers now use Claude for roughly 60% of their own work, up from 28% a year ago, reporting ~50% productivity gains. Claude Cowork was built with Claude Code in 10 days.

That last part is worth sitting with. They used their own tool to build a new product in less than two weeks. The compounding flywheel isn’t theoretical anymore. It’s shipping.

On the business side: $380 billion valuation after a $30B Series G in February. Revenue run-rate at $14 billion, growing 10x annually. Over 500 customers spending $1M+ per year. Eight of the Fortune 10 are Claude customers.

This isn’t a startup experimenting. This is a company executing at a pace that’s forcing the rest of the industry to react.

What actually moved the needle
#

I’m not going to do a tier list—you can find those elsewhere. What I want to do is break down the releases that change how developers work, not just what sounds impressive on a changelog.

The model leap: Opus 4.6 and Sonnet 4.6
#

Opus 4.6 dropped February 5 with serious specs: 1 million token context window, 128K max output tokens (doubled from 64K), full adaptive thinking support, 80.9% on GPQA Diamond, 80.8% on SWE-bench verified. The adaptive thinking shift is important—the model now decides how deeply to reason per turn rather than consuming a fixed budget, which makes it more efficient for mixed workloads where some turns need deep reasoning and others don’t.

Sonnet 4.6 followed on February 17, becoming the default for Free and Pro plans. Near-Opus performance at 5x lower cost ($3/M input, $15/M output), 79.6% on SWE-bench. This is the model that matters most for daily use. If Opus is for the hard problems, Sonnet is for everything else—and “everything else” is 90% of the work.

The compaction API (beta, launched alongside Opus) deserves attention too. Server-side context summarization for effectively infinite conversations. If you’ve been building agents that run into context limits during long sessions, this is the fix you’ve been writing workarounds for.

Computer use + Dispatch: AI that does things
#

I wrote about this when it shipped in late March. Claude can now control your Mac—open apps, navigate browsers, fill spreadsheets, submit PRs. Pair it with Dispatch and you assign tasks from your phone while Claude works on your desktop.

The technical model: Claude reaches for the most precise tool first. Calendar request? Google Calendar connector. Slack message? Slack integration. No connector available? It falls back to screen-based control—mouse, keyboard, browser. The permission model is explicit: Claude asks before touching a new application, and Anthropic scans model activations during computer use to detect adversarial prompt injection.

Mac only. Research preview. It will be unreliable for complex workflows. But the jump from “AI that talks about doing things” to “AI that does things” is real. The security implications are the part that keeps me up at night—prompt injection against a computer-controlling agent is a fundamentally different threat than prompt injection against a chat model.

Claude Code: from assistant to development platform
#

Claude Code had the densest quarter of any product line. The headline features:

Remote Control (Feb 24): Supervise Claude Code sessions from your phone via claude.ai/code. Approve or reject changes, monitor long-running tasks without staying at your desk. This changes the workflow from “sit and watch” to “check in when it matters.”

Hooks: Deterministic actions that fire at lifecycle points—session start/end, file changes, tool use. These run 100% of the time, unlike advisory instructions that the model might ignore. This is the automation primitive that makes Claude Code composable with your existing tooling.

Subagents and /simplify: Parallel workers with clean context windows. /simplify distributes agents across changed files for code review, checking for reuse and quality. /batch handles large migration tasks across multiple files. This is multi-agent execution inside a coding tool—the same architectural direction Cursor 2.0 is taking with worktree-based parallelism.

128K output tokens (up from 16K default, 64K max): Quietly massive for code generation. Combined with the 1M token context window, Claude Code can now reason about entire mid-sized production codebases and generate substantial implementations in a single turn.

This isn’t a coding assistant anymore. It’s a development platform with an agent architecture. The Plugin Marketplace, scheduled tasks, voice mode, and MCP elicitation are all infrastructure for a tool that’s meant to run alongside you, not just respond when prompted.

Connectors: the quiet game-changer
#

Connectors might be the most strategically important release of the quarter. Claude now integrates bidirectionally with Gmail, Slack, Notion, Figma, Asana, Google Drive, and 50+ other tools.

Bidirectional. Not just “read your Slack messages.” Claude can modify content in connected applications. That’s the difference between a search engine and a coworker. It’s the same logic behind MCP—give the AI access to your real context—but packaged as a consumer-friendly feature with zero setup friction.

The strategic angle: every connector is a switching cost. Once Claude is wired into your Slack, Gmail, and Notion, moving to a different AI provider means rewiring all of those integrations. Anthropic understands this. The convenience is real, and so is the lock-in.

Managed Agents and the platform play
#

April 7–9 brought the most architecturally significant releases:

Managed Agents (public beta): A fully managed framework for running Claude as an autonomous agent. Secure sandboxing, built-in tools, SSE streaming. Create agents, configure containers, run sessions through the API.
Advisor Tool (public beta): Pairs a fast executor model with a higher-intelligence advisor for strategic mid-generation guidance. A senior engineer reviewing the junior’s work, but as an API parameter.
ant CLI: Command-line client for the API with native Claude Code integration and YAML-based resource versioning.

Managed Agents is the one to watch. Until now, building production agent systems meant stitching together your own sandboxing, tool management, and execution infrastructure. Anthropic just said “we’ll handle that.” That’s a platform play aimed directly at the middleware layer that startups were building. It’s also the kind of move that makes you more dependent on Anthropic’s infrastructure, not less.

The OpenClaw situation
#

And this is where the story gets uncomfortable.

On April 4, Anthropic blocked Claude subscription access for third-party agentic tools, starting with OpenClaw—the open-source AI agent gateway with over 247K GitHub stars. Users on Pro and Max plans can no longer route their subscription through OpenClaw. They must now use pay-as-you-go “extra usage” billing or direct API access.

Boris Cherny, Anthropic’s Head of Claude Code, explained that “subscriptions weren’t built for the usage patterns of these third-party tools.” The technical argument has merit: OpenClaw achieves ~10% cache hit rates compared to Claude Code’s much higher rates, meaning a single $200/month Max subscriber running OpenClaw continuously could consume $1,000–$5,000 in API-equivalent compute. The economics don’t work at all-you-can-eat pricing.

But the optics are terrible. Anthropic shipped Cowork—which does much of what OpenClaw does—and then cut off the open-source competition. Peter Steinberger, OpenClaw’s creator, characterized it as copying features from the open-source project and then locking out the competition. Whether that’s fair or not, it’s the perception.

OpenClaw’s response was swift. Version 2026.4.5 shipped with GPT-5.4 as the recommended default. “Anthropic cut us off. GPT-5.4 got better. We moved on.” They didn’t just switch models—they built new features around GPT-5.4’s native computer use capabilities. One week to migrate an entire project’s recommended provider.

This isn’t just a drama story. It’s a technical lesson about platform dependency:

If you build on a provider’s subscription model, you’re borrowing capacity they can revoke. OpenClaw users discovered overnight that their $200/month subscription wasn’t a contract—it was a courtesy. API access is still available, but at 5–25x the effective cost for heavy agentic workloads.

The switching cost for model providers is lower than we think. OpenClaw migrated to GPT-5.4 in a week. User testing shows comparable performance after prompt tuning. The model layer is commoditizing faster than any single provider wants to admit. The lock-in is in the tooling, the connectors, the workflow—not the model itself.

Open-source doesn’t protect you from upstream decisions. OpenClaw is MIT licensed. 247K stars. Massive community. None of that mattered when Anthropic decided the economics didn’t work. Your code is open, but your dependency on a closed API is still a single point of failure.

This is exactly why I’ve always maintained a multi-provider workflow. And it’s exactly why Anthropic’s execution makes that stance so conflicted—the tools are genuinely excellent, and using them means accepting the platform risk.

The compounding flywheel (and why it’s hard to ignore)
#

The features are impressive individually. What actually matters is the pace.

Anthropic released a major Claude update roughly every two weeks in 2026. Agent Teams and Opus 4.6 shipped the same week. Code Review landed on a Monday, and by Friday they’d added 1M context GA and four more Claude Code features.

This isn’t speed for speed’s sake. It’s compounding. Each feature makes the next one faster to build, because the team building them uses the tools they’re shipping. That flywheel is the real competitive advantage—not any individual model or feature.

The developer experience data reflects this. Claude Code works first try 91% of the time on feature generation, versus 78% for GPT-5 and 65% for Gemini 2.0.

But speed has costs. The Claude Code source leak happened during this sprint—a packaging error that shipped internal source code. When you’re publishing 60–100 internal releases daily, the boring parts of the pipeline need to be bulletproof. They’re clearly not yet.

And context fragmentation remains unsolved. For all 120+ features shipped, Claude still loses memory across conversations. You can’t hand off a complex multi-day project between sessions without significant re-prompting. The compaction API helps for single long conversations, but the cross-session problem persists.

The basket question
#

Back to my eggs.

I use Cursor. I use Claude. I use ChatGPT when it’s better for the task. I keep my eye on Gemini’s 2M context window, on GitHub Copilot’s agent mode, on what open-source alternatives like OpenClaw (a self-hosted AI agent gateway that routes through your messaging channels instead of a browser tab) are doing—especially now that they’ve demonstrated you can switch providers in a week.

I’m not going all-in on any single provider. After the OpenClaw situation, I’m more certain of that than ever.

In practice, that means most of my daily work runs through Cursor with Claude as the model layer—it’s the best developer experience I’ve found. But my MCP setup is provider-agnostic by design, my prompts don’t rely on Claude-specific quirks, and I keep ChatGPT and Gemini warm for the tasks where they’re genuinely better. If Anthropic changes the economics tomorrow, I want the migration to be a settings change, not a rewrite.

But I’d be dishonest if I didn’t acknowledge what’s happening. Anthropic in Q1 2026 didn’t just ship features. They demonstrated a development velocity that no competitor has matched. They’re eating their own cooking and the compounding is visible. They went from the company behind “the other chatbot” to the company that developers talk about in the same breath as their core infrastructure.

The guys at Anthropic are on the wave. And the OpenClaw story is a reminder that waves carry things—they don’t let you steer.

The question for developers isn’t whether to use Claude. It’s how to use the best tools available without becoming dependent on any one of them. Build your workflows so the model layer is swappable. Keep your context portable. Treat every provider’s pricing model as temporary. And pay close attention to what Anthropic is building—because right now, they’re building faster than anyone else.

Diversification doesn’t mean ignoring the best tools available. It means using them without letting them own you.

What’s your setup? All-in on Claude, spreading your bets, or actively building provider-agnostic workflows? Find me on X, Telegram, or LinkedIn.

Claude Can Now Use Your Computer. Here's What That Actually Means.

Mon, 23 Mar 2026 14:00:00 +0200

Anthropic shipped computer use for Claude today. Not as a demo. Not as a research paper. As a feature in Claude Cowork and Claude Code, available right now for Pro and Max subscribers.

When Claude doesn’t have a direct integration for something you ask it to do, it falls back to controlling your computer like a human would. It uses the screen to navigate. It can click, scroll, open files, use the browser, and run dev tools. No setup required. It just looks at what’s on your screen and figures out how to get the task done.

This is the jump from “AI that talks about doing things” to “AI that does things.”

How it works
#

Claude reaches for the most precise tool first. If you ask it to check your calendar, it uses the Google Calendar connector. If you ask it to send a Slack message, it uses the Slack integration. But when there’s no connector for what you need, Claude controls your mouse, keyboard, and browser directly.

The permission model is explicit. Claude asks before it touches a new application. You can stop it at any point. Some apps are off-limits by default. Anthropic built in safeguards against prompt injection, automatically scanning model activations during computer use to detect adversarial behavior.

Anthropic is upfront about the limitations. Computer use is early. Claude makes mistakes. Complex tasks sometimes need a second try. Screen-based operations are slower than direct API integrations. They’re releasing it as a research preview specifically to learn where it works and where it falls short.

Mac only for now. No Windows, no Linux.

Dispatch makes this actually useful
#

Computer use by itself is interesting. Paired with Dispatch, it becomes practical.

Dispatch shipped last week. It creates a persistent conversation between the Claude mobile app and your desktop. You assign Claude a task from your phone, turn your attention to something else, then open the finished work on your computer.

With computer use, Dispatch becomes a remote control for your Mac. You’re on the train and tell Claude to pull this morning’s metrics and prepare a briefing. You’re in a meeting and tell Claude to make changes in your IDE, run tests, and put up a PR. You’re away from your desk and tell Claude to keep a long-running task moving.

The combination is the interesting part. Computer use gives Claude hands. Dispatch gives you the ability to direct those hands from anywhere.

For developers specifically
#

Anthropic is positioning this heavily toward developers, and it makes sense. Claude can now make changes inside an IDE, submit pull requests, run tests, and navigate development tools autonomously. If you’re already using Claude Code, computer use extends what the agent can reach. Instead of being limited to the terminal and file system, it can interact with any GUI application.

That said, this overlaps with what Cursor Automations does differently. Cursor triggers agents from events (Git pushes, Slack messages, PagerDuty alerts) and runs them in cloud sandboxes. Claude’s computer use runs on your actual machine, which means it has access to everything you have access to. More capability, more risk.

The security implications are obvious. An AI agent with access to your screen, keyboard, and browser is a powerful tool and a significant attack surface. Prompt injection against a computer-controlling agent is a different threat than prompt injection against a chat model. Anthropic says they’re scanning for it, but they also say not to expose sensitive data during the preview.

The bigger picture
#

Every major AI company is racing toward the same destination: AI that doesn’t just generate text but actually operates computers. OpenAI and Google are both working on similar capabilities. Anthropic got here first with a shipped product, even if it’s early.

I’ve been writing about AI agents moving from toys to tools for a while. Computer use is a clear step in that direction. The agent doesn’t need a purpose-built integration for every app. It can use the same interface you use. That dramatically expands what an agent can do without requiring every software vendor to build an API or MCP connector.

But it also means the agent inherits all the messiness of GUI-based interaction. Screens change. Buttons move. Modals pop up unexpectedly. The reliability of screen-based control will always be lower than API-based integration. Anthropic knows this, which is why Claude prefers connectors when they’re available and falls back to computer use only when needed.

The honest framing: this is a research preview. It will be unreliable for complex workflows. It will get better fast. And in six months, we’ll look back at this as the moment AI assistants stopped being confined to chat windows.

The question isn’t whether AI will control computers. It’s how fast the reliability curve catches up to the ambition.

Trying Claude’s computer use or Dispatch? I’d love to hear what tasks you’re assigning and how it handles them. Find me on X or Telegram.

CLI Agent Orchestrator: When One AI Agent Isn't Enough

Wed, 05 Nov 2025 00:00:00 +0000

You’ve hit this wall before. You’re working on some complex modernization project with Claude Code or Amazon Q Developer CLI, and the agent starts losing coherence. Too much context. Too many domains. Architecture bleeding into security bleeding into performance optimization. The agent can’t maintain focus.

Your options have been to manually coordinate between separate agent sessions, copying context around like it’s 2010. Or overload one agent with everything and watch quality degrade as the context window fills up.

AWS to the rescue; they just released CLI Agent Orchestrator (CAO): multiple specialized agents working together under a supervisor. Hierarchical orchestration for your AI CLI tools.

It’s early, opinionated, and requires AWS infrastructure. But it shows where developer AI tooling is headed when single agents aren’t enough.

The Problem
#

Single agents work great for focused tasks. Refactoring? Boilerplate? Debugging? Claude Code or Amazon Q handles it.

But try modernizing a legacy mainframe application. Architecture design, security review, performance optimization, testing, data migration. That’s a project spanning multiple disciplines. Load all that context into one agent and watch quality degrade. The agent contradicts itself, forgets earlier decisions, outputs get generic.

The alternative is running separate agents manually. One for architecture. Another for security. Another for performance. Now you’re copying context between them, manually synthesizing outputs, spending more time coordinating than working. You’ve become the orchestration layer.

CAO is AWS’s answer: a supervisor agent manages specialized workers. Each focuses on its domain. The supervisor handles coordination. Configure the team once, let them collaborate.

How It Works
#

A supervisor agent delegates to specialized workers. One for architecture. One for security. One for performance. The supervisor manages sequencing and maintains context. Workers focus on their specialty and report back.

Each agent runs in its own isolated tmux session. No context pollution. The architecture agent’s history doesn’t leak into the security agent’s work. Sessions communicate through Model Context Protocol (MCP) servers, which handle local communication between the isolated sessions, running entirely on your machine.

CAO supports three patterns. Handoff (synchronous): supervisor waits for completion before proceeding. Assign (asynchronous): supervisor delegates and moves on. Send Message: supervisor checks status without blocking. All implemented through Amazon Bedrock action groups.

Example: Mainframe Modernization
#

The supervisor receives “Create a modernization plan for this COBOL banking system.” It hands off sequentially: architecture agent designs the structure, security agent reviews it, then performance and test agents work in parallel. The supervisor synthesizes outputs into a unified plan.

You could apply this to building microservices applications or migrating monoliths. In practice, you’ll iterate on prompts and intervene when agents drift. But the pattern works when configured well.

The Reality Check
#

CAO only works with Amazon Q Developer CLI and Claude Code. Nothing else has shipped despite “future plans” for other tools.

The supervisor runs on Amazon Bedrock, AWS’s managed service for foundation models. You need AWS credentials, Bedrock access, and an AWS account. It’s open source code you can’t run without AWS infrastructure. This is lock-in you should choose consciously.

Everything runs in tmux sessions. Great for transparency, but it’s another dependency with a learning curve. Running this in CI/CD adds complexity.

Multiple agents mean multiple API calls, more token usage, higher latency. For simple tasks, this is wasteful overkill. You need to be selective about when orchestration overhead is worth it.

This is infrastructure for developers comfortable with AWS, tmux, and orchestration concepts. It’s not polished. Limited early reactions on social media praise the privacy focus but flag AWS lock-in and tmux hurdles as barriers to adoption.

Why It Matters
#

The interesting part isn’t CAO specifically. It’s the shift from “AI tool as standalone assistant” to “AI tools as orchestrated teams.”

Single-agent tools hit walls. Context windows don’t solve everything. At some point, more context just means more noise. Multi-agent architectures divide cognitive labor. Each agent has a focused job. The supervisor ensures pieces fit together.

We’re seeing this everywhere. OpenAI’s Swarm. LangGraph. CrewAI. AutoGPT. The underlying idea is the same: complex tasks need coordination, not just more context. Specialization plus orchestration beats generalization with bigger context windows.

The question: does this remain infrastructure developers explicitly configure, or does it become invisible? CAO is clearly “you configure this.” But the long-term direction is probably toward tools that orchestrate automatically, with developers intervening only when defaults fail.

Getting Started
#

If you want to experiment with CAO:

You need an AWS account with Bedrock access and permissions to use Claude models. Install Amazon Q Developer CLI or Claude Code. Install tmux (brew install tmux on macOS). Clone the repo: git clone https://github.com/awslabs/cli-agent-orchestrator. The README has configuration examples and workflows.

Realistically, plan to spend an afternoon getting this working. This isn’t a tool you spin up in 10 minutes.

Should You Use This?
#

Use CAO if you’re handling complex, multi-disciplinary tasks where single agents struggle. If you’re already on AWS and Bedrock, integration is straightforward. You need comfort with tmux and orchestration concepts.

Skip it if your tasks are straightforward. If you’re not on AWS or want to avoid lock-in, skip it. If you need something polished, this isn’t it.

For most developers, single-agent tools remain the right choice. For teams tackling large-scale modernizations or complex migrations, CAO offers a pattern worth exploring.

Check out the GitHub repository and the AWS blog post.

The future of AI tooling is coordination, not just capability. CAO is AWS’s bet on how that works. Whether it becomes standard or just one experiment, the pattern it represents is where things are headed.

The Context Problem: Why AI Can't Remember You Across Apps (And Why That's Not an Accident)

Mon, 29 Sep 2025 00:00:00 +0000

You just spent 20 minutes teaching Claude your codebase. The mental model is perfect. Claude gets the architecture, knows your constraints, understands the goal.

Then you remember ChatGPT is better at Python refactoring. You switch over.

“Let me explain my project again…”

Stop. Before you paste that context for the hundredth time, let’s talk about what’s really happening here. Not the surface-level “AIs don’t share memory” explanation. The real engineering. The deliberate decisions. The philosophy of what context even means.

Because once you understand how AI memory actually works, you’ll see why this problem exists, and why it might never be “solved” the way you think.

The 10-minute mental model
#

Let’s build your understanding from first principles. Here’s what “context” actually means in AI systems:

1. Context is attention, literally
#

When you talk to an AI, your words become tokens (numerical representations). These tokens flow through attention mechanisms that decide what’s relevant. Context isn’t “stored” like files on disk. It’s a temporary computational state, like RAM, not a hard drive.

Every token costs compute. A 200K context window means the model is actively attending to 200,000 tokens worth of patterns every single time it generates a response. That’s why context is expensive. It’s not storage cost, it’s processing cost.

2. Memory is retrieval, not recording
#

When ChatGPT “remembers” you prefer React, it’s not writing to a database. It’s creating embeddings (mathematical fingerprints of concepts) and storing those in a vector space. Next conversation, it searches that space for relevant patterns and injects them into the context.

Think of it like this: The AI doesn’t remember conversations. It remembers the shape of conversations and reconstructs relevant bits on demand.

3. Sessions are stateless by design
#

Here’s the kicker: Large language models are fundamentally stateless. They’re functions: text in, text out. No persistence. Every “memory” feature is scaffolding built around this stateless core.

Why? Because stateless is scalable. One model can serve millions of users simultaneously. Add state, and suddenly you need persistent storage, session management, consistency guarantees. The infrastructure complexity explodes.

Why context doesn’t transfer (and never will)
#

Here’s where it gets interesting. The context problem isn’t technical. It’s architectural, economic, and philosophical:

The embedding incompatibility problem
#

Each AI uses different embedding models. Claude’s vector representation of “Python” differs from ChatGPT’s differs from Grok’s. Even if they shared raw text, the semantic understanding wouldn’t translate. It’s like trying to share thoughts between brains with different neural structures.

The context window economics
#

A 200K context window at current prices costs about $2-4 per conversation in compute. Multiply by millions of users. Now imagine maintaining that context across sessions, across platforms. The economics don’t work unless someone’s paying (either users directly or through lock-in).

The competitive moat reality
#

Let’s be honest: If Claude context seamlessly transferred to ChatGPT, why would you pay for both? Context lock-in is the subscription retention strategy. Every AI provider knows this. Interoperability is antithetical to their business model.

The philosophical divide
#

Here’s the deep question: What even is context? Is it the raw text? The extracted meanings? The interaction patterns? Each AI platform has a different answer, and those answers are incompatible by design. They’re not just building different features. They’re building different theories of mind.

How the big three actually implement memory
#

Now that you understand the primitives, let’s see how each platform builds “memory” on top of stateless models:

Claude: Structured context hierarchies
#

Anthropic took the “explicit is better than implicit” approach:

Projects as context containers. A Project isn’t just a folder. It’s a persistent context namespace. Documents get chunked, embedded, and indexed. When you chat, Claude runs semantic search across project contents and injects relevant chunks into the prompt. It’s RAG (Retrieval Augmented Generation) with a nice UI.

Artifacts as working memory. These aren’t just displayed code. They’re part of the active context. Claude maintains a pointer to artifact state and includes it in subsequent prompts. Close the browser, lose the pointer.

Constitutional memory. Claude uses constitutional AI principles even for memory. It won’t remember things it shouldn’t (passwords, PII) even if you ask. The memory system has built-in ethical constraints.

The philosophy: Claude treats context like a research assistant would. Organized, hierarchical, and bounded. It’s memory as a filing system, not a stream of consciousness.

ChatGPT: Implicit extraction and injection
#

OpenAI went for “it just works”:

Automatic memory extraction. After each conversation, ChatGPT runs a secondary pass to extract “memorable” facts. These get stored as embeddings with metadata (timestamp, confidence, topic). No user action required.

Probabilistic injection. New conversations trigger similarity searches across your memory bank. High-scoring memories get prepended to your prompt invisibly. You never see this happening. It’s seamless.

Cross-session state. ChatGPT maintains a persistent user profile that evolves. It’s not just remembering facts; it’s building a model of you. Your writing style, reasoning patterns, preferences. All get encoded.

The philosophy: Memory should be invisible and automatic. The AI adapts to you, not the other way around. It’s memory as personality modeling.

Grok: Stream processing and real-time context
#

xAI took the “everything is a stream” approach:

Event-sourced memory. Grok treats conversations as event streams. Each message is an event that updates the state. Memory is the accumulated state changes over time, allowing for precise replay and branching.

Real-time context injection. The X integration isn’t just API calls. It’s streaming context. Grok maintains a sliding window of relevant real-time data that gets mixed with conversational context. It’s the only one doing true stream processing.

Pattern learning over storage. Grok emphasizes learning interaction patterns over storing facts. It’s less “remembers you like Python” and more “adapts to your communication style.”

The philosophy: Context is fluid and temporal. What matters isn’t what was said, but how it relates to what’s happening now. It’s memory as stream processing.

The architectural escape routes
#

Despite the challenges, here are four ways the context problem could be solved. Each with profound implications:

Architecture 1: The Semantic Intermediary
#

Instead of sharing context directly, share semantic representations:

User Context Space
├─ Universal embeddings (model-agnostic)
├─ Semantic graph (relationships)
├─ Intent vectors (what you're trying to do)
└─ Interaction patterns (how you communicate)

How it works: A middle layer that translates between AI-specific representations. Like Unicode for meaning. A universal encoding that each AI can interpret.

Why it’s hard: Requires agreement on semantic primitives. It’s like asking English, Mandarin, and Arabic speakers to agree on universal grammar.

What it would enable: True AI interoperability. Switch models mid-conversation. Use multiple AIs simultaneously on the same problem.

Architecture 2: Federated Context Protocol
#

Borrowed from federated learning:

Context Federation
├─ Local context store (your device)
├─ Encrypted sync protocol
├─ Differential privacy layer
└─ Model-specific adapters

How it works: Your context lives on your device. AIs request relevant portions through a privacy-preserving protocol. You control what’s shared, when, and with whom.

Why it’s powerful: Solves privacy, ownership, and portability simultaneously. Your context becomes a personal asset, not platform property.

The catch: Requires fundamental changes to how AI services work. They’d have to give up data control.

Architecture 3: Context as Computation
#

The radical approach. Don’t store context, compute it:

Generative Context System
├─ Base facts (minimal storage)
├─ Generative rules (how to reconstruct)
├─ Verification hashes
└─ Incremental updates

How it works: Store only essential facts and rules for regenerating context. Like seed-based procedural generation in games. Each AI reconstructs the full context from seeds.

Why it’s elegant: Tiny storage footprint. Perfect consistency. Context can evolve without storing every state.

The challenge: Requires deterministic generation across different models. We’re nowhere close to this.

Architecture 4: The Model Context Protocol (MCP)
#

The standard that actually exists:

Anthropic created MCP to standardize AI-to-data connections. Cursor just shipped deeplinks for MCP. Click a link, install a context server. But here’s the thing:

What MCP actually does: Standardizes how AIs connect to data sources (databases, APIs, documents). It’s plumbing, not memory.

What MCP doesn’t do: Share context between different AI platforms. It’s a connection protocol, not an interchange format.

The reality: MCP is useful but orthogonal to the context problem. It’s like having standardized power outlets but different voltages.

What actually works today (ranked by effectiveness)
#

Forget the future. Here’s how to minimize context pain right now:

Level 1: The Context Discipline
#

Build a system, stick to it:

# CONTEXT.md
## Mental Model
[How I think about this problem]

## Decisions Made
[What we've already figured out]

## Current Focus
[What we're working on now]

## Constraints
[What we can't change]

Update after every session. Start every conversation by pasting this. It’s manual but it works.

Level 2: Context Bridges
#

Tools exist that sync context across AIs:

Browser extensions that capture and replay context
Note-taking tools that become context hubs
Automation platforms that chain AI calls with context

They’re imperfect but better than copy-paste.

Level 3: Single-Tool Mastery
#

The nuclear option: Pick one AI and commit. Learn its memory system deeply. Use its features fully. Let compound context work for you.

Choose based on your primary need:

Deep work: Claude with Projects
Continuous assistance: ChatGPT with Memory
Real-time research: Grok with streaming context

Level 4: Context as Code
#

For developers, the ultimate solution:

class ContextManager:
 def __init__(self):
 self.embeddings = VectorStore()
 self.sessions = {}
 self.memory = PersistentDict()

 def capture(self, ai, conversation):
 # Extract and store semantic patterns
 patterns = self.extract_patterns(conversation)
 self.embeddings.add(patterns)

 def inject(self, ai, prompt):
 # Retrieve and prepend relevant context
 context = self.embeddings.search(prompt)
 return f"{context}\n\n{prompt}"

Build your own context layer. Control everything. It’s work, but you’ll never lose context again.

The next 12 months: Watch these signals
#

The MCP test: If Cursor’s MCP deeplinks gain adoption, context sharing becomes inevitable. If they don’t, we’re stuck with silos.

The memory tax: When someone figures out how to monetize context portability, everything changes. Watch for “context as a service” startups.

The regulation forcing function: GDPR-style rules for AI memory are coming. Portable context might become legally required.

The open source wildcard: One good open source context protocol could force everyone’s hand. The community is building alternatives.

The uncomfortable truth about memory
#

Here’s what this all reveals: We’re trying to solve a human problem with a technical solution.

The context problem exists because we’re using AIs wrong. We treat them like persistent assistants when they’re actually stateless functions. We expect them to remember like humans when they’re designed to compute like calculators.

Maybe the answer isn’t better memory. Maybe it’s better prompting. Better task decomposition. Better understanding of when context helps and when it hurts.

Because here’s the thing: Perfect memory might make AI worse, not better.

Fresh context forces clearer thinking. Explaining again reveals new angles. Starting over prevents assumption lock-in. The context “problem” might actually be a feature.

Your move
#

The context problem isn’t going away. But you don’t have to be its victim:

Build a context discipline today. Simple markdown files beat no system.
Experiment with bridges. Try the tools, see what works.
Question the premise. Do you really need perfect memory? Or better workflows?
Think philosophically. What is context? What is memory? What are you really trying to preserve?

The magic isn’t in perfect memory. It’s in understanding what memory means for intelligence.

And maybe, just maybe, the fact that Claude and ChatGPT can’t share notes isn’t a bug.

It’s a glimpse of how alien artificial intelligence really is.

When someone asks why we don’t have AGI yet, tell them we can’t even agree on what memory means. Then watch them try to define it.

Claude · PiniShv

I Don't Put All My Eggs in One Basket. Anthropic Is Making That Hard.

The numbers that matter #

What actually moved the needle #

The model leap: Opus 4.6 and Sonnet 4.6 #

Computer use + Dispatch: AI that does things #

Claude Code: from assistant to development platform #

Connectors: the quiet game-changer #

Managed Agents and the platform play #

The OpenClaw situation #

The compounding flywheel (and why it’s hard to ignore) #

The basket question #

Claude Can Now Use Your Computer. Here's What That Actually Means.

How it works #

Dispatch makes this actually useful #

For developers specifically #

The bigger picture #

CLI Agent Orchestrator: When One AI Agent Isn't Enough

The Problem #

How It Works #

Example: Mainframe Modernization #

The Reality Check #

Why It Matters #

Getting Started #

Should You Use This? #

The Context Problem: Why AI Can't Remember You Across Apps (And Why That's Not an Accident)

The 10-minute mental model #

1. Context is attention, literally #

2. Memory is retrieval, not recording #

3. Sessions are stateless by design #

Why context doesn’t transfer (and never will) #

The embedding incompatibility problem #

The context window economics #

The competitive moat reality #

The philosophical divide #

How the big three actually implement memory #

Claude: Structured context hierarchies #

ChatGPT: Implicit extraction and injection #

Grok: Stream processing and real-time context #

The architectural escape routes #

Architecture 1: The Semantic Intermediary #

Architecture 2: Federated Context Protocol #

Architecture 3: Context as Computation #

Architecture 4: The Model Context Protocol (MCP) #

What actually works today (ranked by effectiveness) #

Level 1: The Context Discipline #

Level 2: Context Bridges #

Level 3: Single-Tool Mastery #

Level 4: Context as Code #

The next 12 months: Watch these signals #

The uncomfortable truth about memory #

Your move #