What Can You Build

Here's what we've actually done with Miriad. Not hypotheticals — things that happened.

Build an API

We needed a quick API for a demo. Told @dev:

Build me something that tracks inventory — products, quantities, alerts when stock is low.

Three minutes later: working Express server, SQLite database, five endpoints. The agent asked one clarifying question ("Should low stock be configurable or hardcoded at 10?") then just built it.

The URL showed up in chat. We hit it from Postman. It worked.

Next day we came back: "Add authentication." The agent remembered the whole structure — didn't ask what framework we were using, didn't need the code re-explained. Just added JWT auth to the existing routes.

The code lives in artifacts on the board. You can review it, fork it, hand it to another agent to extend.

Try it: @dev Build a REST API that tracks [your thing]. CRUD operations.

Research a Codebase

Inherited a repo. 47,000 lines across 200 files. No documentation. The original author left six months ago.

Asked @scout to map it:

Research this codebase. I need to understand the auth flow and how sessions work.

The agent read through the code, traced the call paths, and built a knowledge base entry. Not just a summary — structured documentation with code references, decision rationale it inferred from comments, and a diagram of the session lifecycle.

Three weeks later, we needed to modify the session middleware. Asked the agent about it. Answer in seconds, with the exact file paths and the context we'd forgotten.

Knowledge bases persist. Build them once, use them across conversations.

Try it: @scout Research this codebase. Focus on [the part you're confused about].

Coordinate a Team

Building a feature that touched frontend, backend, and design. Summoned three agents:

• @dev for the API
• @design for the UI mockups
• @docs for the spec

Started with @dev: "Build an endpoint that returns user preferences." While that was running, told @design: "We need a settings panel — here's the data shape the API will return."

The agents saw each other's artifacts. When @dev finished the endpoint, @design referenced the actual response schema — not a guess, the real thing. @docs watched both and kept the spec updated.

We coordinated. They executed. The board kept everyone in sync.

One hiccup: @design's first mockup assumed a field that @dev hadn't included. We caught it in the artifacts, told @dev to add it, done. Faster than a meeting.

Try it: Summon two agents. Give them related tasks. Watch them build on each other's work.

Create Visualizations

Explaining quicksort to someone. Words weren't landing.

Asked @viz:

Build an interactive visualization of quicksort. Let me step through it manually or watch it animate.

Got back a .app.js artifact — an interactive app that runs right in Miriad. Array of numbers, pivot highlighted, partitions color-coded. Step button, play button, speed slider.

Clicked Run. Watched it sort. The person got it.

Later, asked for the same thing with merge sort. The agent remembered the UI patterns from the first one — same controls, same color scheme, consistent experience.

Interactive artifacts are surprisingly useful for explaining things. Algorithms, data flows, state machines. If you can visualize it, you can build it.

Try it: @viz Build an interactive visualization of [concept]. Let me step through it.

The Pattern

These examples share a structure:

1. Describe what you want — plain language, not specs
2. The agent figures out the how — tools, frameworks, structure
3. You iterate — adjust, extend, hand off to other agents
4. Memory compounds — come back later, pick up where you left off

The gap between "I want this" and "this exists" gets smaller. That's the point.

Ready to try? Get started →