Hopper - AI Agents for Mainframe Operations

TL;DR

TL;DR: Hopper is an MCP (Model Context Protocol) server that connects AI agents directly to mainframe systems, letting you control COBOL and Java workloads through natural language instead of JCL scripts.

Source and Accuracy Notes

• Product: https://www.hypercubic.ai/hopper
• HN Launch: Show HN: Agentic interface for mainframes and COBOL (97 points)
• MCP Protocol: https://modelcontextprotocol.org

This post covers the initial launch version. Enterprise features and on-premise deployment options may differ from the base offering.

What Is Hopper?

Mainframes run on COBOL — a language that predates most of modern computing by decades. Yet banks, insurance companies, government agencies, and airlines still depend on these systems for mission-critical operations. The code base is enormous: an estimated 200+ billion lines of COBOL still in production globally.

Until recently, AI coding tools completely ignored this world. Hopper changes that by acting as a bridge between modern AI agents and the mainframe terminals that control enterprise infrastructure.

Built by the Hypercubic team, Hopper exposes a standard Model Context Protocol (MCP) server that any MCP-compatible AI client can connect to. Once connected, agents can query datasets, execute operations, and orchestrate automated workflows using plain English instead of JCL job control language or 3270 terminal emulation.

If your AI coding workflow already uses Claude, Cursor, or any MCP-enabled toolchain, Hopper gives that same workflow access to mainframe operations without adding a new specialized assistant to your stack.

Setup Workflow

Prerequisites

• Node.js 18 or later
• A mainframe environment with established credentials
• An MCP-compatible AI client (Claude Desktop, Cursor, or any MCP client)

Step 1: Install Hopper

npm install -g @hypercubic/hopper

Step 2: Configure Connection

Create a configuration file at ~/.config/hopper/config.json with your mainframe credentials:

{
  "host": "your-mainframe-host.com",
  "port": 992,
  "protocol": "tls",
  "credentials": {
    "user": "YOUR_USERNAME",
    " пароль": "YOUR_PASSWORD"
  }
}

Connection settings vary based on your mainframe type (IBM z/OS, Unisys, Fujitsu, etc.). The documentation covers adapter-specific configuration for each platform.

Step 3: Connect via MCP

Add the Hopper MCP server to your AI client configuration:

{
  "mcpServers": {
    "hopper": {
      "command": "hopper",
      "args": ["--config", "~/.config/hopper/config.json"]
    }
  }
}

Step 4: First Command

# Query batch jobs currently queued
hopper list-jobs --status QUEUED

# Submit a new COBOL compile job
hopper submit --program MYPROG.COBOL.SOURCE --stream LOG

Deeper Analysis

Why Mainframes Are Hard to Automate

Traditional mainframe automation relies on JCL (Job Control Language) — a declarative syntax for defining batch job workflows. Writing correct JCL requires specialized knowledge that most modern developers do not have. The learning curve is steep, errors are cryptic, and testing requires access to a real mainframe environment.

COBOL programs themselves use a different mental model than modern languages. They work with fixed-format source records (columns 1-6 for line numbers, 7 for indicator, 8-72 for code, 73-80 for sequence), large record-oriented files, and VSAM datasets. AI agents that have never seen this syntax will hallucinate badly unless grounded in actual schema definitions.

Hopper’s approach abstracts all this away. Instead of generating JCL, you describe the desired outcome in natural language. The agent translates that into the correct operations and returns structured results.

MCP as the Integration Layer

Instead of building a proprietary agent wrapper, Hypercubic chose to implement an MCP server. This is a deliberate bet on the growing MCP ecosystem — established by Anthropic and now supported across a wide range of AI tools.

The practical benefit: if your team already uses MCP for other integrations (databases, filesystems, APIs), adding a mainframe connection is a single configuration line, no new SDK or special-purpose client required.

What Can an AI Agent Actually Do?

Based on the launch announcement and early documentation, Hopper supports:

• Browsing and querying datasets across enrolled regions
• Submitting batch jobs and monitoring their status
• Checking input file availability and dataset attributes
• Running prepared automation workflows as discrete steps

This covers the most common DevOps automation scenarios on mainframes: monitoring batch queue health, running end-of-day processing jobs, and checking dataset integrity before downstream feeds.

What It Does Not Cover Yet

At launch, Hopper appears focused on COBOL batch automation and dataset operations. Real-time CICS transactions (interactive 3270 sessions) are a different category of workload and are likely on the roadmap but not yet covered.

Practical Evaluation Checklist

Does it work with my AI client? : Hopper implements the standard MCP protocol. Any MCP-compatible client should work. Test with a personal Claude account first before committing to enterprise deployment.

Which mainframe platforms are supported? : IBM z/OS is the primary target. Fujitsu and Unisys mainframes may work via their respective emulators. Check the Hypercubic documentation for the full platform list.

How are credentials secured? : Credential configuration follows the standard MCP pattern. In production, store mainframe credentials in your secrets manager and inject them at runtime rather than writing them to config files in plain text.

What happens when a job fails? : The agent receives structured error responses from the mainframe. You can implement retry logic in your workflow scripts. There is no built-in alerting system — you would need to connect that to your existing incident management tools.

Can I audit what the agent did? : All operations go through Hopper’s MCP server. Audit logging depends on your MCP client and how you route its output. There is no dedicated audit trail in Hopper itself at launch.

Security Notes

Mainframe credentials carry significant access权限. When integrating Hopper into AI workflows:

• Use a dedicated service account with minimal required privileges, not a privileged mainframe user ID
• Route credentials through your existing secrets manager rather than storing them in config files
• Restrict Hopper’s network access to only the mainframe endpoints it needs to reach
• Review the audit logs from your MCP client to track which operations the agent performed

FAQ

Q: Do I need to know COBOL to use Hopper? A: No. That is the point. Hopper translates natural language from your AI agent into the correct COBOL/JCL operations. You write intent in English; the agent handles the syntax.

Q: Which AI clients work with Hopper? A: Any client that implements the MCP protocol. This includes Claude Desktop (via the desktop app), Cursor, and custom agents built with the official MCP client SDK.

Q: Is this only for batch jobs? A: At launch, Hopper focuses on batch operations and dataset queries. Real-time CICS transactions are not yet supported. Interactive 3270 workloads require a different integration approach.

Q: Does Hopper work with IBM z/OS in the cloud? A: Yes, provided the cloud mainframe environment exposes a standard TCP/IP connection. IBM Cloud for z/OS and other hosted z/OS environments are supported if they expose network connectivity.

Q: How is this different from traditional mainframe RPA tools? A: Most mainframe automation tools work through screen scraping of 3270 terminals. Hopper connects via the MCP protocol to a structured server layer, which is more reliable and auditable than pixel-based automation.

Conclusion

Hopper fills a gap that AI coding tools have ignored for years: the mainframe world. With an estimated 200 billion lines of COBOL still running critical systems, there is enormous demand for developer tooling that makes these environments accessible without requires deep JCL expertise.

If your organization has mainframe workloads and your team already uses MCP-compatible AI clients, Hopper could let you extend existing workflows to cover batch operations, dataset management, and automation scripting — no dedicated mainframe specialist required, at least for routine tasks.

The project is new and the community is still forming. Watch the GitHub repo for expansion to CICS support and additional platform adapters.

Links:

• Product: https://www.hypercubic.ai/hopper
• NPM: https://www.npmjs.com/package/@hypercubic/hopper
• MCP Protocol: https://modelcontextprotocol.org