Overview
MachineAgent brings agentic AI to the Vention platform. Using plain-language prompts, MachineAgent helps you lay out an automation cell, generate the industrial program that runs it, and analyze how deployed machines are performing — across the same design, program, and operate workflow you already use in MachineBuilder, MachineLogic, and MachineAnalytics.
MachineAgent is not a separate application. It is a set of agentic capabilities available at each stage of the automation lifecycle, plus open interfaces — the Vention CLI, the Vention MCP server, and Vention skills — that let you drive the platform from your own AI coding agent.
Requirements
- A Vention account with access to MachineBuilder
- For programming: a design containing a MachineMotion AI controller and at least one supported automation component (see Get started with MachineLogic)
- For deployment to hardware: a MachineMotion AI controller connected to MachineCloud
- For the CLI: a local development environment (Node.js) and an API token — see Command Line Interface (CLI)
- For the MCP server: an AI agent that supports the Model Context Protocol, such as Claude Code, Claude Desktop, Cursor, VS Code, or OpenAI Codex
What MachineAgent Does at Each Stage
| Stage | Capability | Where you use it |
|---|---|---|
| Design | Generate and edit cell layouts from a description | Your Agent + MCP |
| Program | Generate, modify, and debug applications from a prompt | MachineLogic Copilot |
| Program | Drive the platform from your own AI coding agent | Your Agent + Vention CLI + Developer Toolkit |
| Operate | Analyze fleet performance, diagnose issues, and guide remediation | Your Agent + MCP (or logs) |
Installation and Setup
Connecting to the Vention MCP Server with Your AI Agent
The Vention MCP server exposes the Vention platform to any AI agent that supports the Model Context Protocol — including Claude Code, Claude Desktop, Cursor, VS Code, ChatGPT, and Gemini CLI. Once connected, your agent can work with your designs and query your deployed machines in the same conversation where you write your application code.
Connection Information
| Endpoint | https://mcp.vention.com/mcp |
| Transport | Streamable HTTP |
| Authentication | OAuth — no API token to create or store |
| Requires | A Vention account |
Add the endpoint URL to your agent's MCP server configuration. The first time the agent connects, your browser opens a Vention sign-in page. Approve the request and your agent is connected — there is no token to copy or paste.
Every MCP client is configured differently. Use your client's own documentation:
| Client | Setup guide |
|---|---|
| Claude Code | Connect Claude Code to tools via MCP — claude mcp add --transport http vention https://mcp.vention.com/mcp |
| Claude Desktop and Cowork | Get started with custom connectors using remote MCP |
| Cursor | Model Context Protocol |
| VS Code (Copilot agent mode) | MCP servers in VS Code |
| ChatGPT | Developer mode and MCP apps in ChatGPT |
| Gemini CLI | MCP servers |
| JetBrains AI Assistant | Model Context Protocol |
For any client not listed, see the MCP project's Connect to remote MCP servers guide and its directory of MCP clients.
Note: If your client can only launch local MCP servers, check for an update — every client above connects over HTTP directly. Local bridge tools such as mcp-remote are no longer needed and are not supported by Vention.
The server accepts up to 60 requests per minute per user, with a 256 KB request body limit.
Available Tools in the Vention MCP Server
These tools are available today:
| Tool | What it does |
|---|---|
whoami |
Confirms which Vention account your agent is authenticated as |
machine_status |
Returns the latest state reported by a MachineMotion controller, by serial number |
machine_history |
State changes, run time, cycle data, and counter deltas over a time window |
machine_health |
Machine vitals over time: CPU load and temperature, memory and disk usage, per-drive temperature |
machine_activity_log |
A readable event feed including activity like: brake released, drive ready, state changed |
machine_metric |
The raw series for a single numeric metric key, including custom counters from your application |
machine_logs_request |
Requests a machine's logs be packaged for download |
machine_logs_ready |
Returns a download link once the requested logs are packaged |
design_versions_list |
Lists the versions of a design, with their floor plans |
design_graph_download_url |
Creates a short-lived download link for a design version's assembly graph |
design_graph_upload_create |
Creates a short-lived upload URL for a design's assembly graph |
design_version_save |
Saves an uploaded graph as a new version of a design |
design_floor_plan_create |
Creates a floor plan on a design |
design_floor_plan_upload_create |
Creates a short-lived upload URL for a floor plan image |
MachineAgent Skills
A skill is a markdown file that teaches your agent how Vention works — our conventions, workflows, and constraints. Skills complement the MCP server: the MCP server gives your agent access to the platform, while skills give it the judgment to use that access well.
The following skills are available:
| Skill | Use it for |
|---|---|
vention-design |
Building and editing Vention design graphs — agentic machine layout |
vention-programming |
Writing, debugging, and deploying MachineLogic applications |
vention-monitoring |
Diagnosing deployed machines from controller state and analytics |
To get the skill files, contact your Vention representative.
Installing Skills
Claude Code, Claude Desktop, and Cowork
Save the file as SKILL.md inside a folder named after the skill:
- Available in every project:
~/.claude/skills/<skill-name>/SKILL.md - Available in one project only:
.claude/skills/<skill-name>/SKILL.mdin the project root
For example, to install the design skill for all your projects, save it as ~/.claude/skills/vention-design/SKILL.md. Restart your agent, and it will load the skill automatically when a task matches the skill's description.
Other agents
Cursor, VS Code, and other agents use their own filenames and locations for the same idea — Cursor calls them rules, VS Code calls them instructions. The body of each Vention skill works unchanged in any of them; you only need to place it where your client expects, and you can drop the --- frontmatter block at the top, which is Claude-specific.
Using Skills
Once installed, you do not invoke a skill directly — describe your task and your agent loads the matching skill on its own. For example:
- "Lay out a Vention palletizing cell for 400 × 300 mm cases with a UR10e" loads the design graph skill
- "Write a Vention MachineLogic app that indexes the conveyor and picks with the gripper" loads the programming skill
- "Machine 6060009 keeps faulting, what's going on?" loads the monitoring skill
Note: Skills are guidance, not guardrails. Your agent can still be wrong. Review generated designs and applications before you build or deploy them, and treat any diagnosis as a hypothesis to confirm rather than a conclusion.
Using MachineAgent
1. Designing a Facility Layout
MachineAgent can produce a starting cell layout in MachineBuilder from a plain-language description of the application — for example, the part being handled, the process, the robot, and the footprint available.
Use the Vention design skill and Vention MCP Server.
Note: Generated layouts are a starting point, not a validated machine. Review them with the Automated Design Checker and have any safety-relevant design reviewed by a qualified engineer before building.
2. Programming with MachineLogic Copilot
MachineLogic Copilot is the agentic programming interface inside MachineLogic. It has context of your machine's Configuration and any robot Scene Assets already in your design, so you can refer to your actuators, robots, and outputs by name directly in a prompt.
There are two ways to use it:
Generate a new application from a prompt
- Open the MachineLogic tab in MachineBuilder.
- Choose Generate app with Vention Copilot.
- Describe what you want the application to do. Copilot creates the application and opens it for you.
Modify or debug an existing application
- Open a Python application in MachineLogic's Python editor.
- Open the Copilot tab in the bottom panel (use the Vention Extension toggle in the left side panel if the bottom panel is hidden).
- Enter a prompt. Copilot proposes code changes that you Apply and Accept directly in the application.
Tip: Paste errors from the Logs tab straight into Copilot to diagnose and fix a failing application quickly.
Copilot writes against the machine-logic-sdk Python API. For the full editor reference, see the MachineLogic Python Programming Guide.
3. Programming with the Vention CLI and an External AI Agent
The Vention CLI lets you work on MachineLogic applications on your own machine, in your own editor, with your own AI coding agent — including Claude Code. This is the recommended path for complex applications, version control, and teams that already have an agentic development workflow.
The workflow is:
- Install and authenticate the Vention CLI.
- Pull the application and its machine configuration to your local workspace.
- Work locally with your agent of choice against the Developer Toolkit and
machine-logic-sdk. - Push the application back to the platform, then simulate or deploy it.
See Command Line Interface (CLI) and Introduction to the Vention Developer Toolkit.
4. Monitoring and Troubleshooting Deployed Machines
MachineAgent can analyze equipment performance data and logs across a fleet of deployed machines — identifying an underperforming system, diagnosing the operational issue, and guiding you through remediation in plain language.
Use the Vention monitoring skill and Vention MCP Server.
This builds on the data your machines already report to MachineAnalytics:
- Intro to MachineAnalytics — Fleet, Performance, and Health dashboards
- Using MachineAnalytics in MachineLogic
- Monitoring MachineLogic Program Variables Through the MachineAnalytics Dashboard — expose custom metrics from your application
Related Articles
- How to configure, program and simulate with MachineLogic
- MachineLogic Python Programming Guide
- Introduction to the Vention Developer Toolkit
- Command Line Interface (CLI)
- machine-logic-sdk
- Deploy your Configuration and Applications to a MachineMotion
- Intro to MachineAnalytics
- Model Context Protocol documentation — the open standard behind the Vention MCP server