MCP

MeshCrunch MCP prompts: inspect, price, then optimize

MeshCrunch · Engineering ·

Copyable prompts for driving MeshCrunch from an MCP client: reading your asset library, pricing an operation, simplifying, generating LOD chains and converting formats.

On this page

MeshCrunch runs a standard remote MCP server. Any client that speaks the protocol can work with the assets already in your account. It can read your library, price an operation before it runs, then simplify a mesh, generate a level-of-detail chain, or convert a format.

There is no API key to create. You sign in with the account you already have, and an agent is metered by the plan you are already on.

The prompts below start with the ones that cost nothing. Each is written to be pasted as it is and edited afterwards.

Two things worth knowing first

  • An asset is addressed by its id, not by its filename. Naming a file works because the agent lists your assets and matches the name you uploaded under.
  • A connection is scoped. Approve only the read permission, and the server refuses anything that would spend your credits.

That second one is stronger than asking an agent nicely in a prompt. If you are trying this out for the first time, start there.

Quick start

Inspect one model

The smallest useful call, and it costs nothing.

Find `factory.glb` in my MeshCrunch library and summarize its format, file size and geometry counts. Do not run any operation.

Price an operation without running it

Ask what something costs while you can still change the request.

Estimate what it would cost to simplify `factory.glb` in auto mode at balanced quality. Show the credit total, how it was calculated, and how much of my allowance is left. Do not start the job.

The estimate shows its arithmetic: the operation's base cost, and the multiplier for the size band your file falls in.

Simplify, then report

The whole loop: submit, poll, summarize.

Simplify `factory.glb` in auto mode at balanced quality. Poll the job until it finishes, then tell me the triangle count and file size before and after, plus any warnings the run recorded.

Inspect the library

Everything in this section is free, including on a read-only connection.

Find the heaviest assets

Start where the wins are, not with whatever you uploaded last.

List my MeshCrunch assets and rank them by file size. For the five largest, give me the format, size and triangle count in a table, and say which look most worth optimizing. Do not start anything.

Find likely candidates for the web

Ask for reasoning rather than a ranking.

Review my MeshCrunch assets and identify the ones that look unnecessarily heavy for a real-time web viewer. Explain what makes each one a candidate, and stop there.

Check what has already been run

The cheapest saving there is: not buying the same work twice.

Before proposing anything, list the MeshCrunch jobs already run against `factory.glb`. Tell me what each one did, whether it succeeded, and whether its output is still available.

An agent that reconnected has no memory of a job it submitted twenty minutes ago. Your account does, and listing runs is free.

Price before you spend

Price a LOD chain

A chain's length is its price, so this is the estimate worth running.

Estimate the cost of a four-level LOD chain for `building.glb`, using ratios of 1.0, 0.5, 0.25 and 0.1. Show the total and the per-level reasoning. Do not run it.

A level is a ratio of the source, not a rung the server picks. Omit the ratios and a default chain runs instead.

Plan inside a budget

Hand the agent a ceiling and make it do the arithmetic.

Check my MeshCrunch usage, then review my assets. I want to spend no more than 25 processing credits in this session. Propose the highest-impact set of optimizations that fits, with an estimate for each, and wait for my approval.

An estimate reserves nothing. The check that refuses an unaffordable job happens at submission, so a balance can move in between.

Simplify

Choose a quality preset

Auto mode searches for the smallest result inside a fidelity budget. The preset picks the budget.

Simplify `product.glb` in auto mode at near-lossless quality. I care more about preserving appearance than about maximum reduction. Report the result when it finishes, and tell me how far the surface moved.

The presets are near-lossless, balanced and aggressive. Near-lossless is the default, so a prompt naming no quality gets it.

Apply a fixed ratio

For when you know the reduction you want and do not want a search.

Simplify `scan.ply` in ratio mode to 20% of its original geometry. Report the resulting triangle count and file size when it completes.

A ratio is applied in one pass rather than searched for. That makes it faster and more predictable, and it can overshoot.

Discard appearance deliberately

For collision meshes, occluders, and anything never rendered.

Simplify `collision-source.glb` with appearance preservation turned off. This mesh is used for collision only and needs no materials, textures or UVs. Explain what that changes before you run it.

This does more than drop images. UV seams stop being borders the simplifier must respect, so the mesh can collapse much further.

Rebuild the surface for a distant asset

A much smaller mesh, at a cost worth hearing before it runs.

For `city-block.glb`, which is only ever seen at a distance, rebuild the surface at balanced tightness instead of decimating it. Tell me what is lost by doing that, and what it will cost, before you start.

LOD chains

Generate a chain with the ratios you choose

Every level is decimated from the source, so error does not compound down the chain.

Generate a LOD chain for `vehicle.glb` at ratios 1.0, 0.5, 0.25 and 0.08. Estimate it first, ask me to confirm, then run it and report the triangle count and file size of each level.

Let the agent propose the chain

You supply the context. It supplies the ratios.

Inspect `vehicle.glb`. It is a hero prop in a browser scene, visible from roughly 2 to 60 metres. Propose LOD ratios that suit that, explain each level, estimate the chain, and wait for my approval.

MeshCrunch does not know your camera distances. Nothing in the pipeline measures them, so supplying them is what makes a proposal useful.

Rebuild only the far levels

Silhouettes where nobody can tell, real geometry where they can.

Generate a five-level LOD chain for `city-block.glb` and rebuild the surface from level 3 downward, so the last two levels are silhouettes. Estimate it and tell me what those levels give up.

Level 0 can never be rebuilt. A chain whose top rung is not your model is not a chain of your model.

Read a finished chain back

The numbers you need to wire the chain into a scene.

Find the most recent LOD job for `building.glb` and summarize each level: triangle count, file size, and how much smaller it is than the source. Then give me a download link for the level I ask for.

Convert, and pick an output profile

Convert to GLB

Same geometry, different container.

Convert `scan.ply` to GLB. When the job finishes, report the resulting file size and give me a download link.

Ask what will not survive

Formats differ in what they carry. Find out before the credit is spent.

I want to convert `model.glb` to OBJ. Before you start, tell me what material, texture or attribute information will not survive that change, and let me decide whether to go ahead.

Choose an output profile

The largest file-size lever there is, and a compatibility decision rather than a quality one.

Simplify `environment.glb` at balanced quality and write the result as GLB. Explain the difference between the universal, compact and minimum output profiles, tell me which readers each one needs, and recommend one for a three.js viewer I control.

Universal declares no extensions. Compact adds mesh quantization. Minimum adds meshopt compression: much smaller, and it needs a reader that supports it.

Scoped and safe

The prompts here are the second line of defence. The first is the permission you approve when you connect. With only the read permission granted, an agent that decides to simplify something is refused by the server.

Audit without spending anything

The natural first session, and it pairs with a read-only connection.

Audit my MeshCrunch library for optimization opportunities. You may list and inspect assets, list jobs, read my usage and estimate operations. Do not run anything that spends credits. Give me a prioritized list with an estimate against each item.

Always show the estimate and ask

A standing instruction for a session where you do intend to spend.

For the rest of this session: you may inspect and estimate freely, but before every simplify, LOD or conversion job, show me the estimated credit cost and my remaining balance, and wait for me to confirm.

Diagnose a failed run

Understand the failure before paying to repeat it.

Find my most recent failed MeshCrunch job, report its error code and message, and explain what it means and what to try differently. Do not resubmit anything.

The default workflow

MeshCrunch keeps reading and spending apart, and this order falls out of that. State it once at the start of a session rather than repeating it in every prompt.

  • Inspect the asset, so the proposal is about a model rather than a filename.
  • Check your usage if a budget matters.
  • Estimate the exact operation. That prices the job that would actually be submitted.
  • Say what will run and what it will cost, in one sentence.
  • Get approval where the asset or the cost warrants it.
  • Submit, then poll. Processing is asynchronous and returns a job id immediately.
  • Summarize the result, and sign a download link only when one is wanted.

One detail if you build your own automation on this: the spending tools accept a client token. A call retried after a timeout returns the original job instead of buying the work twice.

What you cannot ask for

Four absences shape what is worth prompting for at all.

  • There is no upload tool. Assets arrive through the web app, and mesh data never passes through the MCP server.
  • There is no delete tool. Removing an asset is done in the workspace.
  • There is no way to cancel a job once it is queued or running.
  • There is no REST API, no SDK, no API keys and no webhooks.
MeshCrunch performs the asset operation. Your coding agent combines the result with its own repository and editing tools.

That division is easy to blur when both happen in one conversation. MeshCrunch does not read your repository, does not edit source files, and does not deploy anything. An agent with its own tools can take a finished result and wire it into your project.

You rarely need a complicated prompt

Most of the structure is in the tool contract already. The arguments are validated, the estimate is exact, and the settings are named rather than numeric. A prompt that works generally says four things.

  • Which asset, by the name you uploaded it under.
  • What outcome you want, in your own terms.
  • The constraint that matters: a quality preset, a ratio, or a budget.
  • Whether the agent may spend credits without asking.

Which is to say: `Optimize building.glb for a real-time web viewer. Estimate it first, use balanced quality, and ask me before starting the job.`