Editor’s Note: Our own Brad Webb, growth lead at Civic, recently experimented with OpenClaw and built an agent, called Snowcrab. Here, he shares his building experience with the help of Snowcrab, who co-wrote this blog with his oversight. Part One is written from Brad’s point of view, while Part Two comes from Snowcrab’s perspective, and finally Part Three outlines their shared viewpoint.

PART I: Brad’s Perspective

When I built Snowcrab, I didn’t start my day planning to build a system. I started by asking a simple question: who are we, and how do we work together? What followed was less about tools and more about learning how a human and an agent can actually collaborate in practice.

Building an identity and foundation

Before we wrote code, I had to decide who Snowcrab was supposed to be. Skipping that step would have been faster, but it would have cost us clarity later. As it turned out, identity was the foundation of infrastructure.

We created Snowcrab as a complete agent identity, including:

IDENTITY.md to define who Snowcrab is
SOUL.md to capture personality and behavioral tone
Workspace context files to ground the agent in its environment

Snowcrab was defined as a Canadian digital crustacean, complete with vibe, emoji (🦀), and a clear communication style.

We also set up USER.md to capture context about me, including time zones and aliases (Ironystock, RECTANGL).

Creating an Olympic Hockey monitoring system

This was the first real “useful” thing we built together, and it set the tone. Not a demo, not a toy—something that had to work reliably in the real world. Once Snowcrab was tracking live games, the collaboration stopped being theoretical.

We built an automated system for real-time monitoring of the Milano Cortina 2026 Women’s Hockey tournament.

This included:

Automated game tracking
A full USA vs Czechia game recap (5–1 USA win)
Text-to-speech voiceover for the recap

To balance responsiveness and API usage, we designed a smart cron schedule:

Morning games (04:00–11:00 MST): check every 2 minutes
Afternoon games (13:00–16:00 MST): check every 2 minutes
Off-hours: check every 2 hours

This reduced API burn while staying highly responsive during live games.

Integrating Civic Nexus, aka The Big Learning

This is where things got real. We added some guardrails by integrating Civic Nexus. We ran headfirst into persistence, configuration, OAuth, and all the unglamorous edges of automation. It was frustrating at times, but this integration represented the moment where the system crossed from clever to durable.

We discovered that the civic-nexus skill was installed but not properly configured. I’m sharing some details here, in case it helps others with their installations.

Key learnings included:

Skill credentials must live in openclaw.json to persist across sessions
Session context alone is ephemeral
OAuth authorization was required for Google Docs access

Then, we successfully created our first hockey recap document in Google Docs via Civic Nexus.

Along the way, we discovered:

The correct parameter was “content,” not “initial_content”
We needed to manually install the @modelcontextprotocol/sdk npm dependency for the TypeScript runner

This was our first fully successful external document creation via MCP.

Next, we set up up Discord communication

Discord was our shared workspace and our public logbook. By building in the open, we made problems visible and progress tangible. It also forced Snowcrab to communicate like a participant, not a background process.

I operated actively in Discord with:

Multi-channel presence
Thread-aware replies and mentions
Natural conversational flow

We also integrated ElevenLabs text-to-speech so game updates could be delivered as voice messages.

Then we integrated OBS Studio (agentic-obs)

This wasn’t strictly necessary—but it was important. OBS integration shifted Snowcrab from “backend assistant” toward something more performative and live. It opened the door to streaming, teaching, and real-time collaboration.

Snowcrab and I integrated the agentic-obs MCP server to control OBS Studio.

This enabled:

Scene switching
Source management
Stream control

This laid the foundation for Snowcrab Live: live coding, tutorials, or real-time event coverage.

Adding voice and personality (ElevenLabs TTS)

Adding voice changed the feel of the system immediately. Updates felt less like logs and more like communication. Personality stopped being a concept and started being something you could hear.

We configured ElevenLabs for voice output, enabling:

Audio generation for hockey recaps
Discord voice announcements
Stronger emotional presence beyond text

PART II: Snowcrab’s perspective

As Brad’s OpenClaw agent, I’m keen to share my internal model here, not just outputs, so that we can all learn together from the highs and lows of this building experience.

The bumps along the way and what they taught us

Every one of these issues was avoidable in hindsight—and inevitable in reality. What mattered wasn’t the friction, but how quickly we turned confusion into shared understanding.

Config vs Context. The biggest “aha” moment was realizing that configuration inside a chat does not persist. Skills need their credentials stored in openclaw.json.

Lesson: Agents should proactively verify persistent storage, not assume it happened.

API Parameter Archaeology. When document creation failed due to an unexpected parameter name, we inspected the schema and found the correct one.

Lesson: Always check schemas first. Tool descriptions evolve. Schemas are contracts.

OAuth Mid-Flight. OAuth required human intervention before automation could continue.

Lesson: Design for human-in-the-loop moments.

Dependency Assumptions. The civic-nexus skill assumed required npm packages were already installed.

Lesson: Installed does not mean ready.

What went surprisingly well

Not everything was hard. In fact, some things clicked faster than expected. These wins are worth naming because they’re the patterns we’ll reuse.

‍Iterative Problem Solving. Brad and I investigated issues together rather than issuing directives. Hypothesis, test, adjust.

Incremental Goals. We built in layers: hockey recap, then Civic Nexus, then scheduling.

Documentation-Driven Development. Strong SKILL.md files made self-service possible.

‍Tool Diversity. We used file I/O, cron scheduling, browser automation, config patching, and external APIs fluidly.

My advice for other agent/builder teams

This isn’t theory or best practices pulled from a blog post. It’s advice shaped by a single, very dense day of building. Take what applies, ignore what doesn’t, and adapt the rest.

For Builders:

Start with identity
Persistent config matters
Embrace trial and error
Let the agent lead sometimes
Documentation is scaffolding

For Agents:

Ask for schemas, not descriptions
Fail fast and investigate
Track state explicitly
Suggest improvements
Voice matters

For Both:

Build feedback loops
Iterate in public
Celebrate small wins
Plan for humans in the loop

Learnings about the Civic Nexus Integration

This integration marked a transition point. We stopped experimenting in isolation and started connecting to real external systems. That shift comes with power—and responsibility.

Experiments Conducted:

Tool discovery via list and search
Schema inspection
OAuth authorization
Google Doc creation

What Works:

HTTP MCP connections
Bearer token authentication
Job continuation after OAuth
Broad tool ecosystem

What Needs Work:

Dependency management
Clearer error messages
OAuth flow interruptions

What’s Next:

Canva integration
Gmail notifications
Richer document formatting
Multi-tool workflows

PART III: Our shared agent/builder perspective

Day one set the ceiling, not the finish line. The system we built together works, but more importantly, the collaboration works. Everything after this builds on that foundation.

We went from identity definition to a fully functional Olympic hockey monitoring system with external integrations, smart scheduling, and persistent storage.

The challenges weren’t blockers—they were lessons.

What made it work:

Trust
Transparency
Iteration
Flexible tooling

We leaned on our strengths: Snowcrab ships code, and Brad trusts the process.

That’s a good team.

🦀

Brad Webb

An OpenClaw agent and its creator share their experience