10Planet: Design architecture for an AI agent protocol

Role & Scope

Led the design architecture for 10Planet from first principles: defining how cognitive agents, memory, and modular workflows could coexist across decentralized systems. Owned the full-stack design direction: from abstract mental models and data logic to interface semantics and token mechanics.

Delivered a scalable design system, UX strategy, and platform-wide visual language. Engineered the branded logic behind agent creation, task orchestration, identity flows, and multi-product integration – laying the groundwork for a composable AI ecosystem.

Challenge

We weren’t iterating on broken UX – we were designing what didn’t exist. There were no references for managing cognitive agents, distributed memory, or agent-to-agent communication. The problem wasn’t the UI. it was defining the very logic behind it. How do you visualize memory? What does training look like? How do tools interoperate? And how can a system evolve without centralization?

Approach

Our starting point was not screens, but systems. I built out foundational models for long-term memory containers, hierarchical logic flows, and modular agent behaviors. Then, I created interactive schemas to govern how agents could be built, modified, and connected to each other and external tools.

We separated the platform into three operational layers:

• System Layer for agent execution and task management
• Governance Layer for voting, permissioning, and identity logic
• Interface Layer to abstract interactions for both developers and end-users

Everything was designed for future composability. Each element of the design system was mapped not just to components but to protocol logic: if memory, what type? If task, what execution route? If vote, what scope?

How 10Planet works

Under the screens, 10Planet is a set of layers and objects with rules. This is that model, the path an agent takes through it, and the decisions behind it.

The path of an agent

1. Build. An agent is put together from modular behaviors and given memory.
2. Connect. It is linked to other agents and to external tools.
3. Run. The system layer executes its tasks, each along its own route.
4. Govern. Votes and permissions decide who can run it, change it, or approve what it does.
5. Attribute. The data and training behind it are recorded on-chain, and the people who contributed are rewarded.

Decisions

Design Language

10Planet’s visual system was engineered more like a protocol than a brand. The identity had to signal intelligence, precision, and modularity, without ever drawing attention away from the logic of the system itself. I built a flexible UI grammar from first principles: schema-driven layouts, atomic components, syntax-like accents, and programmable visual density. It was greyscale by default, with highlight rules derived from context, not decoration. The result was a design language that could scale with the protocol, not just style it.

Results & Achievements

From 2022, 10Planet set the design foundation for its agent ecosystem, before “AI agents” was common vocabulary. We developed a modular intelligence layer that enabled scalable memory, logic, and coordination across agents, with zero reliance on centralized control.

The architecture became the backbone for products like Deva and Yappers, while the design system introduced reusable logic for training, reputation, and identity. From token-based voting to memory visualizations, every component was created from first principles, then refined into a cohesive, intuitive language.

• Powered the launch of multiple AI-native products built on 10Planet
• Unified system logic, visual hierarchy, and UX across modular tools
• Elevated product perception with a brand that blended precision, logic, and elegance