Sometimes, the most profound power lies in simplicity and, in this case, the simplest solution has ignited a revolution.
AI agents are no longer just a concept—they’re seizing their moment in history. What began as a niche open-source experiment has, in a matter of weeks, evolved into a global phenomenon. Agents like OpenClaw—formerly known as ClawdBot and MoltBot—have transcended the realm of demos. They’re autonomously navigating the web, executing complex tasks, retaining memory, and interacting with real-world systems in ways that are both exhilarating and unnervingly profound.
And today, we’re releasing a You.com skill for OpenClaw.
Set Ourselves Up for Success
The headline here isn’t just that the integration exists, it’s how quickly we were able to do it.
There was no OpenClaw-specific SDK. No custom adapter. No platform-only abstraction. The integration worked immediately because the interface was already there.
That wasn’t an accident.
From the beginning, we designed You.com’s agent tooling around a simple question: What’s the smallest, most universal interface that every agent already understands?
The answer? The command line interface (CLI).
This is what made it possible to go from zero to production in hours, not weeks, even as the agent ecosystem shifts in real time. This post explains how we did it, why the architecture mattered, and what this moment signals for the future of agent integrations.
The Integration Problem (That Every Agent Platform Has)
Modern AI agents come in many forms:
- IDE extensions (Claude Code, Cursor, Windsurf)
- Standalone tools (OpenClaw, Cody)
- Framework integrations (LangChain, AI SDK)
- Chat-based environments (Custom GPTs, Claude Projects)
Each platform tends to introduce its own integration surface:
- MCP servers
- HTTP APIs
- Framework-specific SDKs
- Custom plugins
The traditional response is to meet each platform where it is.
That approach doesn’t scale.
It leads to:
- Multiple codebases to maintain
- Version drift across integrations
- Platform-specific bugs
- Slower adoption every time a new agent appears
But all of these agents—including OpenClaw—share one thing in common:
They can run command-line tools.
The Insight: Command Line Is the Universal Agent Interface
Instead of asking “How do we integrate with this agent?”
We asked a simpler question:
What’s the smallest interface that already works everywhere?
If an agent can run curl, git, or npm, it can run any CLI tool.
Rather than teaching every agent how to speak our API, we built one command-line interface that agents already know how to use.
That decision is what made the Op integration almost trivial.
Why OpenClaw Worked Instantly
OpenClaw is CLI-native by design:
- It favors composable tools
- It doesn’t require heavy SDKs
- It treats agents like developers treat systems
Because of that, installing You.com inside OpenClaw was as simple as installing the CLI.
No custom glue.
No platform-specific logic.
No new learning curve.
That was the moment the architecture proved itself.
The Three-Layer Architecture
We structured You.com’s agent tooling into three layers, each serving a different audience.
Layer 1: Core API (For Developers)
A lightweight TypeScript package that wraps the You.com search API, AI agent, and content extraction APIs.
Key decision: source-published TypeScript, not bundled JavaScript.
That means:
- Developers can see exactly what the code does
- The same logic can be reused by SDKs, CLIs, and servers
- No duplication across integration types
Layer 2: Command-Line Interface (For AI Agents)
A CLI that agents can call from bash:
bunx @youdotcom-oss/api@latest search --json '{"query":"AI agent frameworks"}' --client OpenClaw
Design choices that mattered:
- JSON input so agents can construct queries programmatically
- Client tracking so we know which agents are using the API
Because OpenClaw already understands how to run CLI tools, this worked immediately.
Layer 3: Agent Skills (For Onboarding)
Instead of static documentation, we built interactive agent skills that guide setup step by step.
Agents are walked through:
- Environment checks (Node / Bun availability)
- API key configuration
- Feature discovery
- Error handling patterns
This turns onboarding into an executable workflow instead of a README.
Key Capabilities That Matter
1. Livecrawl: One Call, End to End
Most search APIs require multiple steps:
- Search for URLs
- Fetch pages
- Extract content
Livecrawl does all three in one call:
- Searches the web
- Fetches matching pages
- Returns clean markdown content
Result: faster agents, fewer API calls, simpler logic.
2. Schema Discovery: No Docs Required
Agents can discover parameters programmatically:
npx @youdotcom-oss/api@latest search --schema
This returns a machine-readable schema describing every available option.
New features appear automatically—no agent updates required.
3. Client Tracking: Know What Actually Matters
Every request includes agent metadata:
CLI/0.1.0 (You.com; OpenClaw)
CLI/0.1.0 (You.com; ClaudeCode)
This lets us:
- See which platforms are gaining traction
- Prioritize support where it matters
- Optimize for real usage, not assumptions
Why This Took Hours, Not Weeks
The entire speed run took 6–8 hours:
- Hours 1–3: Extract core API from an existing MCP package, build the CLI wrapper
- Hours 4–5: Update dependent packages to import the shared core
- Hour 6: Add interactive agent skills
- Hours 7–8: Testing, documentation, validation
The key wasn’t heroics—it was reuse.
The API logic already existed.
The interface was intentionally simple.
The requirements were clear.
What We Learned
1. Interactive Workflows Beat Static Docs
Static documentation explains what’s possible.
Interactive skills help agents actually get set up.
For agents, workflows > pages.
2. @youdotcom-oss/api@latest Keeps Skills Evergreen
By using @youdotcom-oss/api@latest in skill examples, we decoupled skills from package versions.
That means:
- New features appear automatically
- Bug fixes propagate without updates
- Skills don’t rot over time
One skill serves all future versions.
3. The Simplest Interface Scales the Farthest
We could have built:
- A complex SDK
- A platform-specific plugin
- A tightly coupled integration
Instead, we built a CLI that takes JSON and returns JSON.
It works everywhere.
One Implementation, Many Interfaces
The same core package now powers:
- Direct CLI usage for bash-based agents
- TypeScript APIs for applications
- MCP servers
- AI SDK plugins
- OpenClaw, installed via
clawhub, with zero custom code
One codebase.
One test suite.
One mental model.
Why This Matters Now
OpenClaw isn’t an exception—it’s a signal.
The next generation of AI agents will favor:
- Simple interfaces
- Composable tools
- Fast setup
- Minimal lock-in
By betting on a CLI-first, schema-discoverable design, You.com works out of the box with agents that didn’t even exist when we wrote the code.
That’s the real win.
Sometimes the right abstraction isn’t more sophisticated—it’s more obvious.
Try It Yourself
Get an API key:
https://you.com/platform/api-keys
For OpenClaw agents:
npx clawhub install youdotcom-cli
# or
bunx clawhub install youdotcom-cli
For general agent setup (skills):
npx skills add youdotcom-oss/agent-skills --skill youdotcom-cli
Quick CLI test:
bunx @youdotcom-oss/api@latest search --json '{
"query":"AI developments 2026",
"livecrawl":"web",
"livecrawl_formats":"markdown"
}' --client OpenClaw
Explore the Code
.png)
.webp)
.jpg)
.jpg)
.jpg)
