$ use-cases

Real Workflow

TryBayan — AI Music Generation with GitHub Copilot

TryBayan produces serene AI music tracks using GitHub Copilot as the orchestrator and Meta MusicGen-small running locally on an Apple M2 Pro with MPS acceleration. A typical session generates 8–12 WAV variations of a single composition, each 15–45 seconds long, ranging from 2 to 8 MB per file.

The problem without Undisk

Each generation writes to music/track-01.wav, overwriting the previous take. The files are gitignored — too large for version control, and binary diffs are useless. Before Undisk, the workflow was: manually rename track-01.wav → track-01-v3-keep.wav before each re-render. One missed rename and the best take is gone forever.

With Undisk

Copilot writes every take to the same path via write_file. Each write auto-creates an immutable version. After a session, the producer opens the file browser, plays back each version, and restores the best take with one click. No renaming, no manual backups, no lost takes across 40+ iterations of prompt tuning.

Stack: GitHub Copilot · Meta MusicGen-small · Undisk MCP · macOS / M2 Pro

A Coding Agent Rewrites 47 Files — The Senior Dev Keeps 44

A 6-person backend team at a Series A startup needs to migrate their API handlers from Express to Hono. Their Claude Code agent rewrites 47 route files, updates 12 middleware modules, and patches 8 test suites overnight. The agent writes each changed file to a shared Undisk workspace so the team can review every modification before merging anything into the repository.

The problem without Undisk

The agent commits directly to a feature branch. Three of the 47 rewrites introduce subtle regressions — a missing await in one handler, a wrong status code in another, a dropped middleware in a third. Reverting those 3 files via git revert means creating a new commit that re-introduces the original code for all three, but the commit graph gets tangled. With 44 good changes and 3 bad ones spread across a single branch, cherry-picking becomes a merge nightmare.

With Undisk

The senior dev opens the file browser, clicks into each changed file, and diffs the agent's version against the original using get_diff. The 3 bad rewrites are immediately visible. She restores those 3 files to their pre-agent versions with restore_version — the other 44 good rewrites are untouched. Then the team copies the 44 clean files into their repo. Total review time: 25 minutes instead of a half-day merge conflict session.

Stack: Claude Code · Hono · TypeScript · Undisk MCP

3 Agents, 1 Workspace, Zero Cross-Contamination

An analytics team at an e-commerce company runs three autonomous agents every night. Agent A pulls daily sales data from Shopify and writes 30–50 CSV files to raw/. Agent B reads those CSVs, normalizes currencies and SKU codes, and writes clean Parquet-format summaries to processed/. Agent C reads the processed data and generates Markdown executive reports with embedded charts to reports/.

The problem without Undisk

On a Tuesday, Agent B has a prompt regression and writes malformed output to 12 files in processed/. Agent C reads the bad data and generates a misleading executive report that gets sent to the VP of Sales. Worse, Agent B also accidentally writes to raw/sales-2026-04-01.csv — overwriting Monday's clean extract. Now both the source data and the processed output are corrupted. The team has to re-run the entire pipeline from scratch.

With Undisk

Policy guardrails via set_policy enforce path isolation: Agent A can only write to raw/, Agent B to processed/, Agent C to reports/. Agent B's attempt to write to raw/ is rejected server-side before the write hits storage. The 12 bad processed files are restored to Monday's versions with restore_version — Agent C re-runs against the restored data and produces a correct report. No full pipeline re-run. Fix time: 4 minutes.

Stack: Custom MCP agents · Python · Shopify API · Undisk MCP

Every Draft, Every Revision, Every Auditor Question — Answered

A fintech company preparing for SOC 2 Type II uses an AI agent to draft and maintain 23 policy documents — access control procedures, incident response playbooks, vendor risk assessments, data classification matrices, and business continuity plans. Each document goes through 5–15 revision cycles as the compliance team refines requirements with the agent.

The problem without Undisk

The auditor asks: "Show me the change history for your incident response plan. Who made each change, when, and what exactly was modified?" With files stored in Google Drive or a local filesystem, the team scrambles — version history is incomplete, timestamps are approximate, and there's no content hash to prove the documents haven't been tampered with after the fact. The agent's contributions are indistinguishable from human edits.

With Undisk

Every agent write creates an immutable version with a SHA-256 content hash, a timestamp, and the agent ID that made the change. The compliance lead runs list_versions on policies/incident-response.md and shows the auditor 11 revisions over 3 weeks — each with a verifiable content hash. get_diff shows exactly what changed between revision 7 (the one the auditor questions) and revision 8. The audit trail is tamper-evident by construction. EU AI Act Article 12 record-keeping: satisfied.

Stack: Claude · Internal compliance agent · SOC 2 / ISO 27001 framework · Undisk MCP

An Agent Updates 200 Terraform Configs — 3 Were Wrong

A platform team at a mid-market SaaS company manages 200+ Terraform modules across 4 environments. A security policy change requires updating the TLS version in every load balancer config, rotating a set of IAM policies, and patching CORS headers across 38 API gateway definitions. The team deploys a Cursor-based agent to make the changes systematically.

The problem without Undisk

The agent correctly updates 197 files but introduces a syntax error in 2 Terraform modules and applies the wrong IAM policy ARN to a third. In a git-based workflow, these 3 errors are buried in a 200-file diff. The on-call engineer spends 3 hours bisecting the commit, running terraform plan against each environment, and manually reverting the 3 broken files while preserving the 197 correct ones.

With Undisk

The agent writes all 200 updated configs to Undisk. terraform plan catches the 3 failures. The engineer uses search_files to find the broken modules by error pattern, then restore_version on each — 3 clicks, under a minute. The 197 good configs are copied into the repo. Extension rules (set_policy) prevent the agent from writing anything outside *.tf and *.tfvars, blocking accidental state file mutations.

Stack: Cursor · Terraform · AWS · Undisk MCP

8 Hours Autonomous — Every Write Recoverable by Morning

A machine learning researcher at a biotech startup kicks off a literature review agent at 11 PM. The agent searches PubMed and arXiv for 120+ papers on protein folding inhibitors, writes structured summaries to papers/*.md, builds a cross-reference index at index.md, and generates a synthesis document at synthesis/findings.md. By 7 AM, the workspace has 140+ files totaling 2.3 MB of curated research.

The problem without Undisk

At 3 AM, the agent hallucinates a citation — attributing a key finding to a paper that doesn't exist. The hallucinated citation propagates into the synthesis document and cross-reference index. By morning, the researcher can't tell which of the 140 summaries are reliable. On a local filesystem, there's no way to see what the agent wrote at 2:59 AM vs 3:01 AM. The entire 8-hour session is suspect.

With Undisk

The researcher opens the file browser, sorts by modification time, and spots the hallucinated paper at papers/zhang-2025-phantom.md. She uses get_diff on index.md to see exactly when the bad citation was added. She restores index.md and synthesis/findings.md to their pre-3 AM versions — the other 138 summaries are untouched. Rate limits (set via set_policy at 30 writes/min) prevented the agent from flooding the workspace, and extension rules blocked it from writing anything executable.

Stack: Custom MCP agent · PubMed API · arXiv · Claude · Undisk MCP

60 Social Cards in 20 Minutes — Pick the Best, Discard the Rest

A 3-person marketing team at a developer tools company needs social media cards for a product launch. Their Windsurf agent generates 60 SVG variations across 5 design themes — 12 variants per theme — writing each to social/theme-a/card-01.svg through card-12.svg. The creative director reviews them in the file browser, picks the 5 best (one per theme), and restores any accidentally overwritten winners.

The problem without Undisk

The agent iterates on card-07.svg — the creative director's favorite — and overwrites it with a worse variation. On a local filesystem, the previous SVG is gone. Regenerating it requires re-running the exact prompt with the exact seed, which may not be deterministic. The team loses 30 minutes trying to recreate a design they already had.

With Undisk

Every write_file to card-07.svg creates a new version. The creative director uses list_versions to see all 4 iterations, previews each via the file browser, and restore_version to bring back iteration 2 — the winner. Binary file support handles SVGs, PNGs, and PDFs natively. The staged upload API (start_upload → append_upload_chunk → complete_upload) handles high-res PNGs up to 256 MB.

Stack: Windsurf · SVG generation · Undisk MCP

One Workspace, Every Agent, Any Machine — Always in Sync

A solo developer runs Claude Code on a Linux workstation at the office, GitHub Copilot on a MacBook at home, and Cursor on a Windows laptop while traveling. Throughout the day they share status updates, design notes, reference files, and media assets between these agents — posting a morning stand-up summary from one session, attaching a screenshot from another, and picking up right where they left off from a third machine hours later.

The problem without Undisk

Each agent session is isolated. The status update written by Claude Code on the office machine is invisible to Copilot on the MacBook. Sharing a screenshot means emailing it to yourself or dropping it into a Slack channel, then telling the next agent where to find it. Context is lost every time a session ends. By the third handoff, the developer is spending more time re-explaining project state to agents than actually building. Files end up scattered across Dropbox, iCloud, local /tmp folders, and chat histories — with no single source of truth.

With Undisk

Every agent connects to the same Undisk workspace. The morning Claude Code session writes updates/2026-04-07.md with today's status and priorities. At lunch, the developer switches to Copilot on the MacBook — it reads the same file with read_file and has full context immediately. When the developer takes a screenshot of a UI bug, Cursor uploads it via write_file with base64 encoding. Back at the office, Claude Code finds the image with search_files and references it in a bug report. Every text, media file, and status update lives in one versioned workspace — accessible from any agent, any session, any machine. list_files shows the full shared state at a glance. No re-explaining, no lost context, no scattered files.

Stack: Claude Code · GitHub Copilot · Cursor · Multiple machines · Undisk MCP