MBEstudio Workflows: Use It from Claude Code and Your Agent

Agent workflows

From a terminal prompt to a checked system model

Each step is one tool call your agent makes. Free steps never charge. Paid steps show an estimate first and stop at the spending limit you approve.

01Free
Connect and confirm

Add the server once, sign in with your account email in the browser, and ask the agent to check the connection. Here Claude Code calls describe_mbestudio, which never starts a paid job, and lists what it can now do that it could not do alone.

Real session, Claude Code 2.1, October 2026. The last paragraph of the reply, about a stale local note, is cropped.

Setup for each client

claude · ~/mbestudio-demo
02Free
Write a specification, get it checked

The agent writes the system as structured data: functions, components with units, allocations, interfaces, constraints and requirements. estimate_cost runs the same checks the paid tools run and lists every problem as a blocker.

In this session the thermal requirement in the first draft pointed at an attribute that did not exist yet, on purpose, so the blocker is visible. Claude declares the attribute, validates again, and gets a 10 credit estimate before anything is charged.

It also lists the two numbers it filled in itself, a typed mass total and a placeholder case temperature, so an engineer knows what still needs evidence.

Real session, Claude Code 2.1, October 2026, uncropped.

claude · ~/mbestudio-demo

03Paid

Build, verify and simulate

With your approved limit, the agent runs the work it cannot do on its own: compile the specification to SysML v2, check it with the native compiler and shape checks, and execute the declared state machines. Long jobs return an ID immediately, and the result arrives as structured data.

The job appears in your studio workspace, tagged via agent, where you open the model, its source and its findings.

the documented call sequence

// estimate first, then run within the approved limit
estimate_cost({ tool: "build_full_system",
  cost_mode: "agent_authored", specification })
build_full_system({ cost_mode: "agent_authored",
  specification, max_spend_credits: approved_limit,
  request_id })
get_job_status({ job_id })
get_job_result({ job_id })
// returns: SysML v2 source, compiler and shape findings
// with coverage, requirement verdicts over time,
// unmatched events, and the credits actually used

Why connect it

What a general agent cannot do on its own

A coding agent can write SysML text and reason about a design. It cannot compile that text against a SysML v2 implementation, execute the model, or produce results that someone else can rerun. Those are the operations MBEstudio adds.

Engineering operation	An agent alone	The agent with MBEstudio
Compile a system model	Writes SysML text that looks right, with no compiler to say whether it is.	`generate_system_model` compiles a structured specification into a SysML v2 model with requirements and interfaces.
Check the model	Reviews its own output with the same reasoning that produced it.	`verify_model` runs the native compiler and supported shape checks, and reports which areas the checks covered.
Execute behavior	Describes what the state machine should do.	`run_simulation` executes declared state machines and returns transitions, requirement verdicts over time and unhandled events.
Compare alternatives	Argues for a choice.	`run_trade_study` sweeps up to 256 declared design points against stated objectives and returns the Pareto front.
Produce geometry and files	Can write a file, not place parts in an assembly.	`build_3d_model` and `export_model` return envelopes or authored geometry, STL, scene JSON, engineering CSV and HTML reports.
Leave a record	The result lives in a chat transcript.	The model, findings and results land in your studio workspace, where an engineer can inspect and rerun them.

Simulation is discrete. There is no fluid, rigid-body or FMU solver in the agent tools, and satisfaction depends on the equations and inputs the model declares. See the known limits.

Supported clients

Not locked to one assistant

MBEstudio is a remote MCP server at https://studio.vectorstreamsystems.com/mcp. Sign in with OAuth, or use an API key for scripts.

Claude CodeOne terminal command, then /mcp
CodexCLI or desktop settings
CursorOne-click installer
ChatGPTCustom app in developer mode
Claude DesktopCustom connector
GitHub CopilotVS Code agent mode

Setup instructions Add the Skill Pack

Studio workflows

Inspect what the agent built

The same evaluations run in the studio, where an engineer reviews a model whether a person or an agent wrote it.

MBEstudio Requirements view for the Street Racer: 9 requirements satisfied, each with its value, limit and margin, such as curb mass 990.6 kg against a 1200 kg limit.

Requirement evaluation

Read the value, the limit and the margin

Each executable requirement is evaluated against the declared design. Satisfied, violated and indeterminate results stay distinct, and missing inputs are never filled in.

MBEstudio Simulation view for the cinematic quadcopter: requirements over the run, with the endurance requirement violated for the whole flight and mass, thrust, latency and downlink requirements satisfied with their margins.

State behavior

Evaluate through the operating sequence

Run the declared state machines and see when a requirement applies. Intervals where it does not apply are shown as not applicable, not counted as satisfied.

MBEstudio Trade panel for the cinematic quadcopter: 21 design points across battery options and propeller diameter, the Pareto front of endurance against pack mass, beside the 3D drone.

Design alternatives

Compare candidates before committing

Sweep declared alternatives and design variables, inspect feasible and infeasible candidates and the Pareto front, then apply one to the model.

MBEstudio internal block diagram of the Street Racer: wheels and brakes, cabin, powertrain, body and chassis parts with typed ports and connections.

Internal block diagrams

Follow the connections behind the geometry

Typed ports and connections in the diagrams, the 3D assembly and the SysML v2 source describe the same structure.

Try it yourself

Put a model through a design change

MBEstudio 3D view of the Street Racer with internals shown, the model tree on the left and the agent panel on the right.

Pick a model. Open the Model menu and choose a sample, such as the Street Racer or the cinematic quadcopter, or open your own SysML file.
Inspect the assembly. Select parts in 3D and use Internals to look inside.
Follow interfaces. Open Diagrams to see typed ports and connections between parts.
Run the behavior. Open Simulation and press Play to run the declared state machines and see requirement verdicts over time.
Break it. Change a value in the SysML source and watch the affected requirement change from satisfied to violated. Restore it to compare.
Keep the result. Sign in and save a version, or export the SysML source and report.

Open the studio Read the guide

Starting points

Sample systems in the Model menu

Street Racer, performance hatchback, midsize airliner, Home Lab Rack, enduro dirt bike, cinematic quadcopter and autonomous semi truck. Open one, or point your agent at your own specification.

The compiler implements a supported SysML v2 subset, not every construct in the standard.
State simulation is discrete; it does not solve continuous dynamics, thermal behavior or sensor physics.
Agent jobs are reviewed in the workspace; there is no separate per-change approval step yet.

MBEstudio is under active development. For problems or support, email streamline@vectorstreamsystems.com.

Use MBEstudio from the agent you already run.