Agentic Compute logo

Agentic Compute

Runs paid, time-bounded Python workloads in Azure and returns text, cleaned CSV data, optimized models, or locally saved plots.

Install Agentic Compute

Pick your client, then add it in one click or paste the config.

No confirmed install command yet

We only publish a config when the install details come from the project itself β€” its README, its docs, or a verified owner. We haven’t found those for agentic-compute, and we’d rather show nothing than a guess you’d paste into your client.

Open setup steps on GitHub

Overview

The agentic-compute MCP server lets agents run Python computation, clean CSV input, optimize numerical models, and generate Matplotlib plots through Azure Container Apps Dynamic Sessions. An MCP client sends tool calls to a FastAPI backend protected by x402 payments, with USDC settlement on Base and a 15-second execution bound. Plot responses are decoded by the client and saved as local PNG files instead of being returned as image data for model processing. Reach for it when workloads need isolated cloud execution, paid per-call access, or local chart output.

Use cases

  • Execute bounded Python calculations in an isolated Azure session
  • Sanitize raw CSV data before analysis
  • Optimize numerical data for forecasting or curve fitting
  • Generate charts and save them as local PNG files

Key features

  • x402 payment gating with USDC settlement on Base
  • Azure Container Apps Dynamic Sessions execution
  • 15-second execution timeout
  • CSV sanitization and numerical optimization tools
  • Local PNG output for generated plots
  • Local transaction audit records

Security & health

What it can reach and how reliably it runs β€” from our own checks, not the maintainer’s claims.

ActiveLast checked 3d ago

Recent health check succeeded.

How Agentic Compute works

What agentic-compute does

The agentic-compute MCP server exposes four paid tools for data processing and Python execution. execute_code accepts a Python script and returns captured output, with an 8 KB response limit. sanitize_csv converts an unformatted CSV string into a JSON array, including null handling, header normalization, and removal of empty rows.

optimize_ga accepts numerical data and returns model parameters with a MAPE score for forecasting, curve fitting, or related optimization tasks. generate_plot accepts coordinates and chart configuration, then saves the resulting chart locally through the MCP client. The documented tool prices are 0.10 USDC for code execution, 0.25 USDC for CSV sanitization, 0.50 USDC for genetic-algorithm optimization, and 0.30 USDC for plot generation.

How it works

The agentic-compute MCP server uses mcp_client.py as the bridge between an MCP host and the FastAPI backend. The backend applies x402 payment middleware before routing execution requests to Azure Container Apps Dynamic Sessions. An unfunded request receives HTTP 402 Payment Required; funded requests verify the crypto token and settle USDC through the Base network.

Each execution runs in a fresh Azure Dynamic Session with a documented maximum boundary of 15 seconds. The project describes these sessions as isolated microVMs and notes that fresh provisioning can add cold-start latency. Successful and failed transactions are recorded locally with the USDC price, duration, and execution exit code.

For plotting, the Azure sandbox returns the generated payload to the client. The client decodes the image and writes it to local storage, avoiding the need to place base64 image data in the model context. The README identifies optimized_load_trend.png as the generated filename for this workflow.

Setup and configuration

Install the Python dependencies from requirements.txt, create a .env file from .env.example, and configure the Azure pool endpoint and wallet address. Start the backend with Uvicorn on the documented local address and port. The MCP client is configured separately in Claude Desktop using a python command whose argument points to mcp_client.py.

The client configuration also requires an EVM private key and a funded wallet for x402 microtransactions. Keep that key out of source control. The backend and client are separate components, so both must be configured for tool calls to reach the Azure execution pool.

Tools and capabilities

  • Execute arbitrary Python in the remote sandbox; do not use this tool for local filesystem operations.
  • Clean raw CSV strings before analysis by normalizing headers, converting NaN values to null, and dropping empty rows.
  • Optimize numerical data and return parameters with a MAPE result.
  • Generate charts without requiring local GUI dependencies, saving the decoded PNG through the client.

Limitations and notes

The agentic-compute MCP server is not a free local execution service: every tool invocation has a listed USDC price and requires payment configuration. Code output is limited to 8 KB, and execution is bounded at 15 seconds. Empty wallets produce a payment error rather than allowing unpaid execution.

Azure Dynamic Sessions can introduce several seconds of startup time because a fresh environment is provisioned for each request. Plot output is intended to be consumed from the locally saved file rather than read back as base64 data by the model. The repository is released under the MIT License.

Reviews

No reviews yet β€” be the first to share how it worked for you.

Frequently Asked Questions about Agentic Compute

agentic-compute is an MCP server that connects agent clients to Azure Container Apps Dynamic Sessions through a FastAPI and x402 payment gateway. Its main tools execute Python, sanitize CSV strings, optimize numerical data with a genetic algorithm, and generate plots saved locally as PNG files. Calls settle USDC on Base.

Install the dependencies from `requirements.txt`, configure a `.env` file, start the FastAPI backend with Uvicorn, and add `mcp_client.py` to the Claude Desktop MCP configuration. Set the Azure pool endpoint, wallet address, and funded EVM private key before making tool calls.

agentic-compute charges each invocation through x402, with USDC settled on Base. The documented prices are 0.10 USDC for `execute_code`, 0.25 for `sanitize_csv`, 0.50 for `optimize_ga`, and 0.30 for `generate_plot`. An empty wallet receives HTTP 402 Payment Required.

The server uses an MCP client bridge launched with Python, so Cursor configuration would need to support that MCP transport and command, but the repository does not verify or describe it.

Related MCP servers

Add a badge to your READMEShow it’s listed β€” live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewAgentic Compute AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/agentic-compute?style=directory)](https://allmcps.com/mcp/agentic-compute)
HTML Embed
<a href="https://allmcps.com/mcp/agentic-compute"><img src="https://allmcps.com/api/badge/agentic-compute?style=directory" alt="Agentic Compute on AllMCPs" /></a>