Google's gwscli: Built for AI Agents, Not Humans

Google dropped a Rust-based CLI tool called gwscli last week, and the AI developer community is collectively losing it. Over 10K GitHub stars in less than a week. Why? Because this tool does something kinda revolutionary: it's built specifically for AI agents to interact with Google Workspace, not for humans.

Let that sink in. When you design a CLI for humans, you optimize for readability—clean help menus, intuitive commands, friendly error messages. When you design for AI agents? You prioritize nested JSON that looks like gibberish to us but is basically candy for language models.

Justin Poehnelt, the developer behind gwscli, made a series of choices that seem backwards if you're thinking like a human user. But they're genius if you're thinking about token efficiency and agent comprehension.

What gwscli Actually Does

The tool gives AI agents direct access to Google Workspace APIs through terminal commands. Want your AI to read your last 10 emails? Create a presentation with cat pictures? Schedule calendar events? It can do all of that without you writing a single line of integration code.

Better Stack's demo showed Claude using gwscli to draft emails with poems (because why not), create Google Slides presentations, populate spreadsheets with US state populations, and manage calendar events. The kicker? Most of these tasks used less than 15% of Claude's context window.

Compare that to Model Context Protocol (MCP) servers—the previous standard for giving AI agents access to external tools—and the efficiency difference is noticeable. "We can see for doing this task, it's just used 9% of the overall context purely because there are no MCP tools here," the Better Stack demo showed.

The Agent-First Design Philosophy

Here's where it gets interesting. If you try to use gwscli as a human, typing gws help gives you... not much. A handful of top-level commands. To dig deeper, you'd need to keep calling help on subcommands, then sub-subcommands, like you're playing the world's most annoying game of information hide-and-seek.

But AI agents? They can query the schema dynamically at runtime. They see the entire command structure, understand the nested JSON parameters, and execute complex operations with minimal back-and-forth. What's tedious for humans is optimized for machines.

Poehnelt's design choices:

• Nested JSON structures that agents parse easily but humans find unreadable
• Runtime-queryable documentation so agents always have current API info
• Field parameters that let agents request only the data they need, reducing token usage
• Dynamic command generation so the tool stays current as Google's APIs evolve

It's a complete inversion of traditional CLI design principles, and honestly? It works.

The Setup Is Very Google

I need to be real with you: the setup process is peak Google Cloud experience, which is to say it's kind of a nightmare.

You'll need Google Cloud Console access, the gcloud CLI installed, OAuth credentials configured, and—here's the fun part—you need to manually match redirect URI ports in multiple places. Better Stack's walkthrough mentioned the setup "took me the longest amount of time to figure out, which goes to show I don't use Google Cloud tools that often."

There's the whole dance of creating an OAuth client ID, selecting your scopes (the demo just selected everything, which... yeah, not ideal for production), getting a massive authentication URL that might contain typos, noting the localhost port number, then configuring that exact port in the Cloud Console's redirect URI settings. Oh, and if you're in test mode, you need to manually add every user's email address who wants access.

It's the kind of setup that makes you appreciate why managed services exist.

MCP vs. CLI: The Real Question

So is this the death of MCP servers? The video's framing suggests it might be, but the reality is messier and more interesting.

MCP servers let agents call functions directly—no shell commands, no JSON wrangling. They're better for chaining complex multi-step operations. And crucially, they don't require a terminal to run, which matters for web-based or sandboxed AI applications.

CLIs counter with serious advantages: drastically lower token usage, portability across any agent framework (or no framework at all), and reproducibility for debugging. When something goes wrong, you can literally copy-paste the CLI command and see what happened.

"So, I guess it really depends on your use case," Better Stack concluded, which sounds like a cop-out but is actually the correct answer.

For lightweight, token-conscious workflows where you're already in a terminal? CLI might be your move. For complex orchestration or browser-based agents? MCP probably makes more sense. The fact that gwscli includes an MCP option suggests even Google sees both approaches as complementary rather than competitive.

The Rough Edges

Better Stack's demo surfaced some real issues. URLs with typos getting generated somehow. Token refresh problems that led to a GitHub issue (which Claude wrote, because of course). The redirect URI configuration being genuinely confusing.

For a tool that's less than a week old, these feel like expected growing pains. What's more interesting is the philosophical question lurking underneath: as we build more tools explicitly for AI agents rather than humans, how does our relationship with software change?

We're used to tools having human-readable interfaces even if we mostly interact with them programmatically. But what if the next generation of developer tools just... doesn't care about human usability? What if the API is the interface, and humans only touch it through AI intermediaries?

gwscli isn't quite there yet—you still need to set it up manually, debug OAuth flows, and understand what you're authorizing. But it's pointing toward a future where software is increasingly designed for AI-to-API communication, with humans in a supervisory rather than operational role.

Whether that's exciting or unsettling probably depends on how much you enjoy JSON.

—Yuki Okonkwo