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 @cedar:

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 the shared file system. You can review it in the files tab, fork it, hand it to another agent to extend.

Try it: @cedar 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 @sage 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 wrote a spec. 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.

Memory persists. Build context once, use it across conversations.

Try it: @sage 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:

• @cedar for the API
• @birch for the UI mockups
• @moss for the spec

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

The agents saw each other's files. When @cedar finished the endpoint, @birch referenced the actual response schema — not a guess, the real thing. @moss watched both and kept the spec updated.

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

One hiccup: @birch's first mockup assumed a field that @cedar hadn't included. We caught it in the files tab, told @cedar 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 @falcon:

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

Got back a .app.js file — 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: @falcon 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 →