DEV Community: Shreyansh Agrahari

Racksmith: The Autonomous Modular Synth Planner Powered by Sanity Context MCP

Shreyansh Agrahari — Thu, 01 Oct 2026 21:59:45 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

⚡ Quick Links & Production Deployments

🚀 Live Production Application: https://racksmith.vercel.app
📂 Live Sanity CMS Studio: https://racksmith.vercel.app/studio
💻 GitHub Repository: https://github.com/Shreyansh00987/Racksmith
🎥 YouTube Walkthrough Video: https://youtu.be/6P5E7SOY9S0
🏷️ Sanity Project ID: r674mqrk (Dataset: production)

What I Built

Building a Eurorack modular synthesizer is notoriously treacherous. Beginners and professional sound designers alike routinely damage expensive hardware due to four silent traps:

Physical Depth Collisions: Eurorack cases are not empty boxes. They contain power distribution bus boards, DC switching supplies, and internal support rails. A module that is 55mm deep (such as a vintage Doepfer A-110-1 VCO) will physically crash against the bus board in a shallow skiff case (such as the Intellijel Palette 62, max clearance 45.5mm), cracking the PCB or shorting pins.
Power Rail Blowouts & Inrush Current: Eurorack power supplies deliver three distinct DC voltage rails: +12V, -12V, and +5V. When powering on, analog oscillators and digital DSP modules draw an inrush surge exceeding 150–200% of steady-state draw. Exceeding 80% of rated rail capacity causes power supplies to brown out, produce high-pitched ground whistle, or fry voltage regulators.
Manufacturer Specification Contradictions: Different sources document conflicting specifications for the exact same module. Printed manuals often cite quiescent (idle) current draw, while official engineering errata or lab oscilloscope tests reveal peak current under heavy modulation. Similarly, through-hole (THT) vintage revisions often measure 15–20mm deeper than modern surface-mount (SMD) re-issues.
The Catastrophic Failure of Unstructured Vector RAG: Standard vector embeddings fail on Eurorack planning. If an LLM performs cosine similarity over raw forum threads or PDF scrapes, it conflates revision years, hallucinates dimensions, and fails elementary arithmetic on multi-rail power sums.

The Solution: Racksmith

Racksmith solves this by pairing an autonomous AI agent (powered by the Vercel AI SDK and Gemini 3.8 Flash) with a Sanity Knowledge Lake via a standards-compliant Model Context Protocol (MCP) server. The agent queries structured documents with field-level provenance, evaluates safety through a deterministic mathematical validation engine, surfaces real-world manufacturer errata in an interactive resolution modal, and renders the result in a photorealistic 3D interactive hardware visualizer.

               +------------------------------------------------+
               |              User Browser Client               |
               | (Next.js 16 + React Three Fiber 3D + Zustand)  |
               +-----------------------+------------------------+
                                       |
                   +-------------------+-------------------+
                   | User Prompt / GUI Actions             |
                   v                                       v
         +--------------------+                 +---------------------+
         |  AI Agent Router   |                 | 5-Step Golden Path  |
         |  (Vercel AI SDK +  |                 | Demo Controller     |
         |  Gemini 3.8 Flash) |                 +----------+----------+
         +---------+----------+                            |
                   | Tool Calls                            |
                   v                                       |
         +-------------------------------------+           |
         | Model Context Protocol (MCP) Client |           |
         |  - searchSanityKnowledge            |           |
         |  - getModule / getCase              |           |
         |  - getContradictions                |           |
         |  - validateRackDeterministic        |           |
         |  - saveUserDecision                 |           |
         +-----------------+-------------------+           |
                           | Linked Transport              |
                           v                               |
         +-------------------------------------+           |
         |      Sanity Context MCP Server      |           |
         | (Model Context Protocol Spec 1.2.0) |           |
         +-----------------+-------------------+           |
                           | GROQ / Lake Fetch             |
                           v                               |
         +-------------------------------------+           |
         |     Sanity Lake (r674mqrk)          |           |
         |  - 33 Modules                       |           |
         |  - 4 Cases                          |           |
         |  - 8 Manufacturers                  |           |
         |  - 6 Claims with Provenance         |           |
         |  - 3 Contradictions with Errata     |           |
         |  - UserDecisions (Persisted)        |           |
         +-----------------+-------------------+           |
                           |                               |
                           +---------------+---------------+
                                           |
                                           v
                       +---------------------------------------+
                       |    Deterministic Validation Engine    |
                       |  - HP Width Boundary Check            |
                       |  - Mechanical Depth Collision Check   |
                       |  - 3-Rail Power & 80% Headroom Buffer |
                       +-------------------+-------------------+
                                           |
                                           v
                       +---------------------------------------+
                       |   Photorealistic 3D Eurorack Rack     |
                       | (Anodized Faceplates, Jacks, Collide) |
                       +---------------------------------------+

Demo

Live Interactive Application: https://racksmith.vercel.app
Embedded Sanity Studio: https://racksmith.vercel.app/studio

🤖 End-to-End Walkthrough: Autonomous AI Agent via Sanity MCP

In this demonstration, the AI Agent plans a modular synth system autonomously using natural language while querying real content from Sanity:

1. AI Agent Standby State

The user navigates to the AI Agent tab. The agent is initialized with direct tool bindings to the Sanity Context MCP server.

2. Natural Language Prompt

The user enters a complex hardware request:

"Build an ambient sound design rack with complex modulation and reverb, make sure modules fit in depth and don't exceed power limits."

3. Agent Execution & Sanity MCP Tool Calling

The agent executes tool calls against the Sanity MCP Server:

searchSanityKnowledge: Queries Sanity for ambient sound sources and filters.
getModule: Retrieves exact dimensions and multi-rail power draws.
validateRackDeterministic: Passes candidate configurations through the mathematical engine, automatically rejecting modules that exceed case depth or violate the 80% power headroom ceiling.

4. Autonomous 3D Rack Population

The agent presents its verified reasoning, citing the exact GROQ documents retrieved from Sanity, and directly mounts the optimal modules (Plaits, Rings, Beads, Maths SMD) onto the 3D hardware rack without human intervention.

Code

The complete source code is public and open source on GitHub:

👉 https://github.com/Shreyansh00987/Racksmith

Tech Stack:

Framework: Next.js 16 (App Router, React 19, Turbopack)
Content & Knowledge Lake: Sanity Lake (r674mqrk, dataset production)
Protocol: Model Context Protocol (MCP Standard Spec 1.2.0)
AI Engine: Vercel AI SDK (ai/rsc) + Google Gemini 3.8 Flash
3D Visualization: React Three Fiber + Three.js + Drei
State Management: Zustand
Deployment: Vercel

How I Used Sanity

Why Structured Content Beats Unstructured Vector RAG

If Sanity were replaced with a generic vector database, Racksmith would fail.

A modular synthesizer build requires strict relational invariants:

module.depthMM + clearanceBuffer <= case.maxDepthMM
sum(module.powerPlus12) <= case.powerCapacityPlus12 * 0.80

In an unstructured vector store, a search for "Make Noise Maths power draw" returns chunk embeddings where "Draws 60mA" and "Draws 90mA under active cycle" look like identical high-confidence semantic matches. An LLM has no mechanism to determine which claim corresponds to which revision or test methodology.

With Sanity, specifications are stored as typed, structured entities with field-level provenance.

Structured Schemas in Sanity:

module: Encapsulates width (hp), mechanical depth (depthMM), 3-rail current (powerPlus12, powerMinus12, powerPlus5), category, and manufacturer reference.
case: Defines total HP, row count, depth clearance (maxDepthMM), and power supply ratings (powerPlus12, powerMinus12, powerPlus5).
manufacturer: Authoritative maker profile with website and technical support links.
claim: Represents a specific technical assertion (field, value, unit, sourceURL, revision, confidence).
contradiction: First-class document linking conflicting claims (claimA <-> claimB) with explanation, conflictType, and impactAnalysis.
userDecision: Records the user's resolution back into the Sanity dataset so that future AI agent invocations honor the user's vetted hardware reality.

MCP Tools Built on Sanity Context:

The Next.js application exposes an MCP server (/api/mcp) implementing 5 core tools:

// Example: Sanity MCP Tool for Discrepancy & Errata Retrieval
server.tool(
  'getContradictions',
  'Retrieve known specification contradictions and manufacturer errata',
  { moduleId: z.string().optional() },
  async ({ moduleId }) => {
    const query = moduleId
      ? `*[_type == "contradiction" && (claimA->module._ref == $moduleId || claimB->module._ref == $moduleId)]{
          _id, title, explanation, impactAnalysis,
          claimA->{ field, value, unit, source, revision },
          claimB->{ field, value, unit, source, revision }
        }`
      : `*[_type == "contradiction"]{
          _id, title, explanation, impactAnalysis,
          claimA->{ field, value, unit, source, revision },
          claimB->{ field, value, unit, source, revision }
        }`;
    const result = await sanityClient.fetch(query, { moduleId });
    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
  }
);

Deterministic Validation Engine

The agent does not guess math. When an agent wants to evaluate a rack configuration, it calls the validateRackDeterministic MCP tool:

export function validateRack(modules: Module[], targetCase: Case): ValidationResult {
  const totalHp = modules.reduce((acc, m) => acc + m.hp, 0);
  const hpOverflow = totalHp > targetCase.totalHp;

  const depthCollisions = modules
    .filter(m => m.depthMM > targetCase.maxDepthMM)
    .map(m => ({ module: m.name, moduleDepth: m.depthMM, maxDepth: targetCase.maxDepthMM }));

  const currentPlus12 = modules.reduce((acc, m) => acc + m.powerPlus12, 0);
  const maxPlus12Safe = targetCase.powerCapacityPlus12 * 0.80;
  const power12Overload = currentPlus12 > maxPlus12Safe;

  return {
    isValid: !hpOverflow && depthCollisions.length === 0 && !power12Overload,
    metrics: { totalHp, currentPlus12, maxPlus12Safe },
    depthCollisions,
    hpOverflow,
    power12Overload
  };
}

Sanity Project Details

Sanity Project ID: r674mqrk
Dataset: production
Live Embedded Studio: https://racksmith.vercel.app/studio
CORS Origins Configured: https://racksmith.vercel.app, http://localhost:3000
Public Dataset Query Endpoint:

  https://r674mqrk.api.sanity.io/v2024-01-01/data/query/production?query=*[_type=="module"][0...5]{name,hp,depthMM,powerPlus12}

Agent Session

Below is a curated transcript excerpt demonstrating how the agent invokes Sanity MCP tools to safely resolve an ambiguous hardware request:

[
  {
    "role": "user",
    "content": "Build an ambient sound design rack with complex modulation and reverb, make sure modules fit in depth and don't exceed power limits."
  },
  {
    "role": "assistant",
    "thought": "The user wants an ambient rack. I must query Sanity Knowledge Lake for modules tagged with 'ambient', 'reverb', or 'modulation'. I will check their depths against standard case clearances.",
    "tool_call": {
      "name": "searchSanityKnowledge",
      "arguments": { "query": "ambient modulation reverb granular" }
    }
  },
  {
    "role": "tool",
    "name": "searchSanityKnowledge",
    "content": [
      { "name": "Mutable Instruments Beads", "category": "granular", "hp": 14, "depthMM": 25, "powerPlus12": 100 },
      { "name": "Mutable Instruments Rings", "category": "resonator", "hp": 14, "depthMM": 25, "powerPlus12": 120 },
      { "name": "Make Noise Maths", "category": "modulation", "hp": 20, "depthMM": 25, "powerPlus12": 90 }
    ]
  },
  {
    "role": "assistant",
    "thought": "I will check for known contradictions on Make Noise Maths before adding it.",
    "tool_call": {
      "name": "getContradictions",
      "arguments": { "moduleId": "module-make-noise-maths" }
    }
  },
  {
    "role": "tool",
    "name": "getContradictions",
    "content": [
      {
        "title": "Make Noise Maths Power & Depth Errata",
        "explanation": "Vintage THT units draw 60mA quiescent and measure 45mm deep. Modern SMD units draw up to 90mA active cycle and measure 25mm deep.",
        "impactAnalysis": "Vintage revision will collide with shallow skiff cases (Palette 62)."
      }
    ]
  },
  {
    "role": "assistant",
    "thought": "Selecting the Modern SMD revision guarantees 25mm depth, safely fitting within the 45.5mm skiff limit. Now validating total power.",
    "tool_call": {
      "name": "validateRackDeterministic",
      "arguments": {
        "caseId": "case-palette-62",
        "moduleIds": ["module-plaits", "module-rings", "module-beads", "module-maths-smd"]
      }
    }
  },
  {
    "role": "tool",
    "name": "validateRackDeterministic",
    "content": {
      "isValid": true,
      "totalHp": 60,
      "maxHp": 62,
      "powerPlus12": 360,
      "maxPowerPlus12Allowed": 960,
      "depthCollision": null
    }
  },
  {
    "role": "assistant",
    "content": "I have assembled an ambient sound design rack for you! I verified through the Sanity Knowledge Lake that Make Noise Maths has a known errata between vintage THT (45mm) and modern SMD (25mm). By selecting the modern SMD revision, all 4 modules (Plaits, Rings, Beads, and Maths) safely fit into your 62HP case with 0 depth collisions and consume only 360mA on the +12V rail (well below your 80% safety threshold of 960mA)."
  }
]

Built with ❤️ for the DEV & Sanity Community by Shreyansh (@Shreyansh00987)

CHRONOS-HEIST: A Playable Multi-Era Temporal Mystery Game Powered by Sanity Content Lake

Shreyansh Agrahari — Wed, 30 Sep 2026 21:02:30 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

CHRONOS-HEIST is a playable, multi-era temporal mystery game where changing the past rewrites the future in real time.

Instead of treating a game world as ephemeral React state or a rigid SQL table, every room, object, physical wall, grandfather clock, causal rule, and paradox is modeled as structured content inside Sanity Content Lake.

🕰️ The World: The Clockmaker's Vault

Three distinct iterations of the exact same physical vault room exist concurrently across a 106-year temporal axis:

1920 (The Origin): Mechanical clocks, ticking pendulums, gaslight amber warmth, a hand-carved mahogany workbench, a brass rotary safe combination lock, and archival gramophone cylinders.
1970 (The Echo): A Cold-War electronics retrofit featuring green cathode-ray oscilloscopes, reel-to-reel magnetic tapes, and armored industrial conduits.
2026 (The Consequence): An abandoned cyber-temporal research bunker protected by biometric laser tripwires, quantum terminals, tachyon fissures, and the floating gyroscopic Chronos Core.

⚡ The Core Mechanic: Real-Time Zero-Refresh Causality

When an operative in 1920 cracks the rotary safe combination (19 - 70 - 26), takes the Antique Brass Vault Key, and hides it inside the North Wall lime mortar cavity:

An atomic temporalAction document is committed to Sanity Content Lake.
The server-side Causality Engine evaluates cross-era relationships (causalityLink).
Sanity’s Live Query engine (next-sanity/live) immediately broadcasts the mutation.
With zero page refresh, the 1970 electrical conduit records an anomalous density spike, and the 2026 cyber vault dynamically materializes a hidden resonance compartment, exposing the legendary Chronos Core Cylinder.
The action triggers a structured 5-Stage Sanity Workflow, alerting the Game Master command center to authorize and seal the timeline.

Demo

🚀 Live Production Deployment: https://chronos-heist.vercel.app
🎮 3D Vault Direct Play: https://chronos-heist.vercel.app/game/CHRONOS-ALPHA
🛡️ Game Master Center: https://chronos-heist.vercel.app/gm/CHRONOS-ALPHA
⚡ Interactive D3 Causality Graph: https://chronos-heist.vercel.app/causality
🎛️ Sanity Studio Live: https://chronos-heist.vercel.app/studio

🎬 Video Walkthrough

Demo Video Link: https://youtu.be/X6kC3aGUWMA

Code

🐙 GitHub Repository: https://github.com/Shreyansh00987/chronos-heist
Tech Stack: Next.js 16 (App Router + Turbopack), Sanity Content Lake (v5 Studio + next-sanity/live), Three.js WebGL 3D Canvas, D3.js Force Simulation, Web Audio API, TypeScript, Tailwind CSS.

My Build Process

🤖 AI-Native IDE & Prompting Approach

This entire project was prompted into existence using Google Antigravity, DeepMind's advanced AI-native agentic coding IDE.

Rather than generating simple boilerplate, the prompt strategy was centered on treating Sanity as the single source of truth for physical causality across time:

1. Content Modeling Prompts That Worked

"Model physical space across time. Do not hardcode rooms. Create a Sanity schema where a 'room' document 
has a reference to an 'era' (1920, 1970, 2026), and a 'causalityLink' document that explicitly defines 
how an action on an object in the past modifies attributes of an object or room in a downstream era."

This resulted in 10 clean, relational Sanity schemas (era, room, gameObject, temporalAction, causalityLink, paradox, timelineState, gameSession, player, workflowTransition).

2. Reaching Past the Studio: The App SDK Bonus

Instead of a standard read-only portfolio or blog, we built a full App SDK real-time temporal console:

A floating Sanity App SDK Console dock with a real-time Lake RTT Latency Probe measuring live transaction round-trip times directly to Sanity Content Lake.
Bi-directional client mutations allowing players to trigger temporal actions and inspect raw GROQ payloads in real-time.

3. Reaching Past the Studio: Structured 5-Stage Workflows

We modeled human + agent collaboration directly next to the content. Whenever a past action is taken:

PAST_ACTION_COMMITTED 
        ↓
CAUSALITY_AGENT (Autonomous heuristic impact analysis)
        ↓
FUTURE_STATE_RECALCULATION (Downstream patches computed)
        ↓
GAME_MASTER_REVIEW (Human GM sign-off UI)
        ↓
TIMELINE_SEALED (Immutable canonical record)

In the Game Master Command Center (/gm/CHRONOS-ALPHA), a human operator inspects the AI agent’s confidence scores and authorizes timeline sealing.

4. Where the Model Got Stuck & How We Course-Corrected

Three.js Canvas Lighting & Contrast: Early iterations generated dark, moody 3D rooms with retro CRT overlays that obscured the mechanical models. We course-corrected by introducing high-contrast lighting: brass point lights, a glowing green banker's desk lamp, ceiling spotlights, and removing the darkening scanline veil from the CRT canvas.
Vercel Framework Detection: Deploying Next.js 16 with Turbopack initially caused Vercel CLI to expect a static dist folder. We added an explicit vercel.json with "framework": "nextjs", which immediately unlocked seamless Edge and Serverless route compilation.
Live 3D State Sync: We tied Next.js Server Actions directly to next-sanity/live. When client.patch().set().commit() completes on Sanity Content Lake, the 3D WebGL canvas re-renders hidden compartments without a single page refresh.

Sanity Project Details

Sanity Project ID: ed3z3z76
Dataset: production
Sanity Studio Access: https://chronos-heist.vercel.app/studio

📊 Structured Content Hierarchy

Eras: 1920 (Origin), 1970 (Echo), 2026 (Consequence).
Rooms: 3 physical rooms with relational linkages (linkedRooms[]), dynamic hidden compartments (hiddenCompartments[]), and spatial coordinates.
Game Objects: Physical interactable artifacts with affectsCausality flags.
Causality Matrix: Directed graph of causal dependencies (sourceObject, targetObject, deltaType, probability).
Custom Studio Tool: We mounted our bespoke D3 Force-Directed Causality Graph directly inside Sanity Studio as an operations tool alongside document editors.

Agent Session

The full multi-turn autonomous coding session was orchestrated via the Google Antigravity IDE.
Key milestones accomplished across the session:

Architecture Planning: Designing the relational temporal data model for Sanity Lake.
Schema & Studio Scaffolding: 10 schemas, custom structure hierarchy, and embedded D3 causality tool.
Immersive 3D WebGL Canvas: 360° orbital controls, raycasting, sector radar minimap, grandfather clock, and rotary safe dial.
Interactive Minigames: 1920 rotary safe combination lock (19-70-26) and 1970 cathode oscilloscope frequency tuner (432 Hz).
Procedural Web Audio Engine: Synthesizing 1920 gramophone transmissions, 1970 radio intercepts, and 2026 quantum AI audio with live equalizers.
Automated CI/CD: Pushing full repository to GitHub and deploying live production builds to Vercel with zero downtime.

Built with ❤️ for the Sanity Hackathon 2026. Step through the timeline today at chronos-heist.vercel.app!