Last week, two of China’s top AI platforms—Doubao and Qwen—suddenly tightened controls on third-party agents. Dozens of workflows were disabled, permissions revoked, and publishing rules overhauled. For English-language tech coverage, the story barely registered; neither platform wields significant influence beyond China. Yet the pattern is anything but rare. In fact, it’s becoming routine across the industry. What set this episode apart, though, was the scale of disruption. The agents being purged weren’t experimental chatbots—they were production-grade tools that teams had spent months building, fine-tuning, and integrating into daily operations. Deleted. Without warning.
If you’ve been in software long enough, you recognize this plot. Twitter’s API fee hikes shuttered entire ecosystems of third-party clients overnight. OpenAI’s GPT platform once buzzed with thousands of user-built agents, only for most to vanish into obscurity when organic discovery collapsed. Slack, Notion, Discord—every platform that opens a door for developers eventually slams it shut, either by absorbing top features, throttling access, or burying third-party work where no one can find it. The reason isn’t malice; it’s fiduciary duty. Public companies serve shareholders, not independent builders. The surprise isn’t that platforms change the rules—it’s that developers still act as if this time will be different.
Take traditional SaaS: you can export your data, migrate to another service, and rebuild. The process is painful, costly, but your core asset—your data—remains portable. Agents are different. Their value isn’t stored in a database; it’s embedded in prompt engineering, API integrations, function schemas, and model-specific quirks. Change the model version or deprecate an endpoint, and the entire workflow can collapse. Teams learned this the hard way when a provider’s new release broke half their prompts—with no way to pin the old version.
That’s why local deployment is gaining momentum. Running inference on your own hardware, storing weights locally, and controlling every API surface eliminates remote kill switches. You decide when to upgrade. Your data never leaves the device. We built Mano-P with this philosophy in mind. The GUI agent runs entirely on Apple Silicon Macs, using a 4B quantized model that achieves 76 tokens per second on an M4 Pro with 4.3GB peak memory. It processes on-screen content via vision—no app APIs required—and never transmits screenshots. On OSWorld benchmarks, it scored 58.2%. Building it this way demanded far more effort than wrapping a cloud API. The reward? What you end up with is actually yours.
On-device execution solves one set of problems, but real-world agents quickly hit another: coordination. Most business processes aren’t trivial; they require multiple agents working in sequence. Execution state must be tracked across steps. Human reviews, iterations, and feedback need persistent storage. Teams must retain shared conventions—otherwise, every new hire or model swap means starting from scratch. Most cloud platforms hand you a prompt box and call it a day. Orchestration, task lifecycle management, human-in-the-loop review, organizational memory—these are the invisible layers you must build yourself.
That’s where Octo comes in. Our open-source workbench is designed for human-AI collaboration, built from the ground up to be model-agnostic. The runtime layer supports OpenClaw, Claude Code, Codex, Hermes, or any self-hosted open-source model. Swapping models doesn’t break workflows or wipe accumulated preferences. Deploy it on your own infrastructure, and all collaboration records stay under your control—no remote off switch.
Octo organizes work into Loops, which emerge from natural language requests rather than rigid forms. Describe the task, assign an agent, and the loop activates. The agent executes, attaches deliverables for review, and closes the loop when complete—or returns it with feedback. Every rejection spawns a Preference entry, which the agent retrieves automatically in future runs. Reject a report for starting every paragraph with a summary? The next time the agent tackles similar work, it avoids that pattern. Team preferences, style guides, and domain rules accumulate without manual re-training, ensuring consistency across users and model versions.
The shift from cloud-dependent agents to local-first tooling isn’t just pragmatic—it’s necessary. Platforms will continue to evolve, but their incentives will never align with yours. By owning the stack end to end, you control your fate. The trade-off is harder engineering, but the payoff is independence. The next time a platform changes the rules, your agents won’t just survive—they’ll thrive.
AI summary
Platforms routinely pull the plug on third-party AI agents. Local deployment offers resilience, control, and data privacy—but requires new tools and trade-offs.
