modexia-compute-agent 0.1.0__tar.gz

modexia_compute_agent-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: modexia-compute-agent
+Version: 0.1.0
+Summary: Autonomous AI agent for deploying containers on Akash Network via Modexia AgentPay
+Author-email: Modexia <hello@modexia.software>
+Project-URL: Repository, https://github.com/modexia/modexia-compute-agent
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: langchain-core>=1.2.23
+Requires-Dist: langchain-groq>=1.1.2
+Requires-Dist: langgraph>=1.1.4
+Requires-Dist: modexiaagentpay>=0.1.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.3.3
+
+<div align="center">
+  <img src="https://modexia.software/favicon.ico" alt="Modexia Logo" width="80" height="80">
+  <br>
+  <h1>🚀 Modexia Compute Agent</h1>
+  <p><b>Autonomous AI agent for deploying Docker containers on Akash via natural language.</b></p>
+
+  [![PyPI](https://img.shields.io/pypi/v/modexia-compute-agent.svg)](https://pypi.org/project/modexia-compute-agent/)
+  [![Python versions](https://img.shields.io/pypi/pyversions/modexia-compute-agent.svg)](https://pypi.python.org/pypi/modexia-compute-agent)
+  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+The **Modexia Compute Agent** is a powerful Python CLI application that turns plain English descriptions into running Docker containers on the [Akash Network](https://akash.network).
+
+Powered by the **Modexia AgentPay** engine over the Squid Router, this agent features *true abstract deployments*. Simply instruct the agent to deploy a container, and it will handle the SDL generation, Akash wallet creation, and **Just-In-Time (JIT) USDT/USDC cross-chain funding + Gas Fee swaps** completely autonomously.
+
+---
+
+## ✨ Features
+
+* **🗣️ Conversational Deployments:** Describe your container, CPU, RAM, and storage needs in plain English.
+* **🧠 Llama 70B Orchestration:** Uses Groq's high-speed inference to flawlessly orchestrate complex blockchain provider interactions.
+* **💳 JIT Cross-Chain Funding:** No AKT? No problem. The agent automatically bridges USDC from your Modexia Vault natively covering AKT gas fees, ensuring seamless workflow.
+* **🔮 Oracle Vibe GUI:** A sleek, beautiful, minimalist `rich` UI ensuring deploying compute feels incredibly satisfying.
+
+---
+
+## ⚡ Installation
+
+Install globally using `pip` or `pipx`:
+
+```bash
+pip install modexia-compute-agent
+```
+
+---
+
+## 🚀 Quick Start & API Setup
+
+Upon running the CLI for the first time, our interactive **Setup Wizard** will launch immediately and seamlessly guide you through connecting all necessary services over 4 quick steps.
+
+Simply run:
+```bash
+modexia-compute
+```
+
+### What You'll Need During Setup:
+
+#### 1. Akash CLI (`provider-services`)
+We rely on the official Akash binary to securely generate wallets and sign transactions purely on your local machine (your mnemonic seed phrase is safely stored exclusively in `~/.modexia/`).
+
+* **Linux / macOS Installation:**
+  ```bash
+  curl -sSfL https://raw.githubusercontent.com/akash-network/provider/main/install.sh | bash
+  ```
+
+#### 2. Modexia AgentPay API Key
+Modexia is the payment orchestration layer that allows the agent to intelligently fund your Akash wallet from external chains.
+
+* Sign up at [Modexia.software](https://modexia.software)
+* Fund your Vault with USDC (on Base).
+* Create a Developer API Key (`mx_live_...`).
+
+#### 3. Groq API Key
+The agent's "brain" is powered by extremely fast LLaMA models. 
+* Free keys at [console.groq.com/keys](https://console.groq.com/keys)
+
+---
+
+## ⌨️ How It Works
+
+Type your intent in plain English, and the oracle goes to work:
+
+```
+> Spin up an NGINX frontend cache on a fast server with 2 CPUs and 4GB RAM.
+```
+
+1. **Manifest Generation:** The LLM instantly writes a verified `SDL (deploy.yaml)` for Akash.
+2. **Auto-Fund Engine Check:** Identifies an empty Akash wallet and bridges exactly `$5.10 USDC` required for escrow and AKT gas natively from your Modexia Vault.
+3. **Provider Bidding:** Connects to Akash, polls live decentralized datacenters, and reports back.
+4. **Approval Loop:** Asks the human precisely which provider is preferred.
+5. **Liftoff:** Container initializes and exposes the assigned NodePort/URI securely!
+
+---
+
+## ⚙️ Modifying Configuration Later
+
+At any time, you can edit your setup or switch APIs. Your configuration is securely stored off-package in your home directory:
+
+```bash
+~/.modexia/compute.env
+```
+
+To forcibly re-run the setup wizard:
+```bash
+modexia-compute --setup
+```
+
+---
+
+*Powered by the Modexia-Verse* 🌌

modexia_compute_agent-0.1.0/README.md

@@ -0,0 +1,101 @@
+<div align="center">
+  <img src="https://modexia.software/favicon.ico" alt="Modexia Logo" width="80" height="80">
+  <br>
+  <h1>🚀 Modexia Compute Agent</h1>
+  <p><b>Autonomous AI agent for deploying Docker containers on Akash via natural language.</b></p>
+
+  [![PyPI](https://img.shields.io/pypi/v/modexia-compute-agent.svg)](https://pypi.org/project/modexia-compute-agent/)
+  [![Python versions](https://img.shields.io/pypi/pyversions/modexia-compute-agent.svg)](https://pypi.python.org/pypi/modexia-compute-agent)
+  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+The **Modexia Compute Agent** is a powerful Python CLI application that turns plain English descriptions into running Docker containers on the [Akash Network](https://akash.network).
+
+Powered by the **Modexia AgentPay** engine over the Squid Router, this agent features *true abstract deployments*. Simply instruct the agent to deploy a container, and it will handle the SDL generation, Akash wallet creation, and **Just-In-Time (JIT) USDT/USDC cross-chain funding + Gas Fee swaps** completely autonomously.
+
+---
+
+## ✨ Features
+
+* **🗣️ Conversational Deployments:** Describe your container, CPU, RAM, and storage needs in plain English.
+* **🧠 Llama 70B Orchestration:** Uses Groq's high-speed inference to flawlessly orchestrate complex blockchain provider interactions.
+* **💳 JIT Cross-Chain Funding:** No AKT? No problem. The agent automatically bridges USDC from your Modexia Vault natively covering AKT gas fees, ensuring seamless workflow.
+* **🔮 Oracle Vibe GUI:** A sleek, beautiful, minimalist `rich` UI ensuring deploying compute feels incredibly satisfying.
+
+---
+
+## ⚡ Installation
+
+Install globally using `pip` or `pipx`:
+
+```bash
+pip install modexia-compute-agent
+```
+
+---
+
+## 🚀 Quick Start & API Setup
+
+Upon running the CLI for the first time, our interactive **Setup Wizard** will launch immediately and seamlessly guide you through connecting all necessary services over 4 quick steps.
+
+Simply run:
+```bash
+modexia-compute
+```
+
+### What You'll Need During Setup:
+
+#### 1. Akash CLI (`provider-services`)
+We rely on the official Akash binary to securely generate wallets and sign transactions purely on your local machine (your mnemonic seed phrase is safely stored exclusively in `~/.modexia/`).
+
+* **Linux / macOS Installation:**
+  ```bash
+  curl -sSfL https://raw.githubusercontent.com/akash-network/provider/main/install.sh | bash
+  ```
+
+#### 2. Modexia AgentPay API Key
+Modexia is the payment orchestration layer that allows the agent to intelligently fund your Akash wallet from external chains.
+
+* Sign up at [Modexia.software](https://modexia.software)
+* Fund your Vault with USDC (on Base).
+* Create a Developer API Key (`mx_live_...`).
+
+#### 3. Groq API Key
+The agent's "brain" is powered by extremely fast LLaMA models. 
+* Free keys at [console.groq.com/keys](https://console.groq.com/keys)
+
+---
+
+## ⌨️ How It Works
+
+Type your intent in plain English, and the oracle goes to work:
+
+```
+> Spin up an NGINX frontend cache on a fast server with 2 CPUs and 4GB RAM.
+```
+
+1. **Manifest Generation:** The LLM instantly writes a verified `SDL (deploy.yaml)` for Akash.
+2. **Auto-Fund Engine Check:** Identifies an empty Akash wallet and bridges exactly `$5.10 USDC` required for escrow and AKT gas natively from your Modexia Vault.
+3. **Provider Bidding:** Connects to Akash, polls live decentralized datacenters, and reports back.
+4. **Approval Loop:** Asks the human precisely which provider is preferred.
+5. **Liftoff:** Container initializes and exposes the assigned NodePort/URI securely!
+
+---
+
+## ⚙️ Modifying Configuration Later
+
+At any time, you can edit your setup or switch APIs. Your configuration is securely stored off-package in your home directory:
+
+```bash
+~/.modexia/compute.env
+```
+
+To forcibly re-run the setup wizard:
+```bash
+modexia-compute --setup
+```
+
+---
+
+*Powered by the Modexia-Verse* 🌌

modexia_compute_agent-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "modexia-compute-agent"
+version = "0.1.0"
+description = "Autonomous AI agent for deploying containers on Akash Network via Modexia AgentPay"
+authors = [
+    { name = "Modexia", email = "hello@modexia.software" }
+]
+urls = { Repository = "https://github.com/modexia/modexia-compute-agent" }
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "python-dotenv>=1.1.0",
+    "httpx>=0.28.1",
+    "langchain-core>=1.2.23",
+    "langchain-groq>=1.1.2",
+    "langgraph>=1.1.4",
+    "modexiaagentpay>=0.1.0",
+    "pyyaml>=6.0.3",
+    "rich>=14.3.3",
+]
+
+[project.scripts]
+modexia-compute = "modexia_compute_agent.cli:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+modexia_compute_agent = ["soul.md"]
+
+[tool.uv.sources]
+modexiaagentpay = { path = "../../packages/SDKs/pythonSdk" }

modexia_compute_agent-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

modexia_compute_agent-0.1.0/src/modexia_compute_agent/agent.py

@@ -0,0 +1,169 @@
+from typing import List, Dict, Any, Optional
+from langchain_core.tools import tool
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_groq import ChatGroq
+
+from modexia_compute_agent.sdl import generate_sdl
+from modexia_compute_agent.akash_cli import create_deployment, fetch_bids, create_lease, send_manifest, get_lease_status, generate_akash_key, check_akash_balance
+from modexia_compute_agent.payments import check_modexia_balance, fund_akash_wallet
+
+# --- TOOLS ---
+
+@tool
+def generate_akash_key_tool(key_name: str = "mykey") -> str:
+    """
+    Creates a new Akash wallet locally using provider-services.
+    Call this when the user needs to get started or lacks an Akash wallet.
+    Returns the wallet address and 24-word recovery mnemonic.
+    Tell the user to back up their mnemonic!
+    """
+    try:
+        return generate_akash_key(key_name)
+    except Exception as e:
+        return f"Error generating key: {str(e)}"
+
+@tool
+def check_akash_key_tool(key_name: str = "mykey") -> str:
+    """
+    Checks if a local Akash wallet key exists.
+    Call this FIRST before any deployment to verify the user's setup.
+    Returns the wallet address if found, or an error if no key exists.
+    """
+    import subprocess
+    result = subprocess.run(["provider-services", "keys", "show", key_name, "-a"], capture_output=True, text=True)
+    if result.returncode != 0:
+        return f"No Akash key '{key_name}' found. The user needs to create one using generate_akash_key_tool."
+    return f"Akash wallet found: {result.stdout.strip()}"
+
+@tool
+def check_balance_tool() -> str:
+    """
+    Checks the user's Akash on-chain balance and Modexia USDC balance.
+    Call this when the user asks about their balance or before deploying.
+    """
+    try:
+        akt = check_akash_balance()
+        usdc = check_modexia_balance()
+        return f"Akash wallet: {akt:.4f} AKT | Modexia account: {usdc:.2f} USDC"
+    except Exception as e:
+        return f"Error checking balances: {str(e)}"
+
+@tool
+def deploy_container_tool(image: str, cpu: float, ram_mi: int, storage_mi: int, port: int) -> str:
+    """
+    Generates an SDL manifest and submits a deployment request to the Akash network.
+    Call this when the user wants to deploy a new container.
+    Returns the DSEQ (deployment sequence ID) of the newly created deployment.
+    CRITICAL: If this tool returns an error string (e.g., Error creating deployment), DO NOT retry blindly. Immediately report the exact error to the user!
+    """
+    print(f"ModexiaAgent: Generating SDL deploy.yaml for {image}...")
+    sdl_path = generate_sdl(image, cpu, ram_mi, storage_mi, port)
+    
+    # --- JIT Funding Check (best-effort, non-blocking) ---
+    try:
+        balance = check_akash_balance()
+        if balance < 5.0:
+            deficit = 5.0 - balance
+            funding_amount = deficit + 0.1
+            print(f"ModexiaAgent: Wallet balance {balance} AKT is too low. Attempting JIT funding of {funding_amount:.2f} USDC...")
+            try:
+                tx_id = fund_akash_wallet(funding_amount)
+                return (
+                    f"Just-In-Time funding initiated! Bridged {funding_amount:.2f} USDC to your Akash wallet (Tx: {tx_id}). "
+                    f"Cross-chain transfers typically take 3-5 minutes. "
+                    f"Once funds arrive, ask me to 'deploy again' and I will submit the SDL. "
+                    f"DO NOT call any other tools until the user confirms."
+                )
+            except Exception as fund_err:
+                # JIT funding failed — inform the user but don't crash
+                return (
+                    f"⚠️ Your Akash wallet balance is {balance} AKT (need ~5 AKT for deposit). "
+                    f"I tried to auto-fund via Modexia but got an error: {str(fund_err)}. "
+                    f"You can manually send AKT to your wallet and then ask me to 'deploy again'. "
+                    f"DO NOT retry this tool automatically."
+                )
+    except Exception as e:
+        print(f"ModexiaAgent: Balance check failed ({e}), proceeding with deployment attempt anyway...")
+
+    # --- Submit deployment ---
+    print("ModexiaAgent: Submitting deployment to Akash...")
+    try:
+        dseq = create_deployment(sdl_path)
+        return f"Deployment submitted successfully! DSEQ: {dseq}. Now use fetch_bids_tool with this exact DSEQ to check for provider bids."
+    except Exception as e:
+        return f"Error creating deployment: {str(e)}. DO NOT retry — report this exact error to the user."
+
+@tool
+def fetch_bids_tool(dseq: str) -> str:
+    """
+    Polls the Akash network for open provider bids for a specific deployment (DSEQ).
+    Call this ONLY after deploy_container_tool has successfully returned a real numeric DSEQ.
+    DO NOT pass placeholder strings. DO NOT call this in parallel with deploy_container_tool.
+    """
+    try:
+        bids = fetch_bids(dseq)
+        if not bids:
+            return f"No bids found yet for DSEQ {dseq}. Please instruct the user to wait or try again."
+        
+        # Format the bids nicely to return to the LLM
+        result = f"Found {len(bids)} bids for DSEQ {dseq}:\n"
+        for bid in bids:
+            # Check structure
+            bid_data = bid.get("bid", bid) if isinstance(bid, dict) else {}
+            provider = bid_data.get("bid_id", {}).get("provider", "Unknown provider")
+            price = bid_data.get("price", {}).get("amount", "Unknown price")
+            result += f"- Provider: {provider} | Price: {price} uUSDC/block\n"
+            
+        result += "\nAsk the user which provider they would like to accept."
+        return result
+    except Exception as e:
+        return f"CRITICAL TOOL ERROR: fetch_bids_tool failed: {str(e)}. Inform the user exactly what went wrong and DO NOT retry blindly."
+
+@tool
+def accept_lease_tool(dseq: str, provider: str) -> str:
+    """
+    Accepts a bid from a specific provider, funds the Akash wallet using Modexia USDC,
+    creates the lease on-chain, and sends the manifest to start the container.
+    Call this ONLY after the user explicitly approves a provider bid.
+    DO NOT pass placeholder strings. DO NOT call this in parallel with deploy_container_tool!
+    """
+    try:
+        # Hardcoded $2 USDC for demo escrow - just an assumption for standard deployments
+        bal = check_modexia_balance()
+        print(f"ModexiaAgent: Current Modexia USDC Balance: {bal}")
+        if bal >= 2.0:
+            fund_akash_wallet(2.0)
+        else:
+            print("Warning: Insufficient Modexia balance to auto-fund, proceeding anyway.")
+            
+        print(f"ModexiaAgent: Accepting bid from {provider}...")
+        create_lease(dseq, provider)
+        
+        print("ModexiaAgent: Sending Manifest...")
+        # Currently sdl generation path is statically deploy.yaml
+        sdl_path = "deploy.yaml"
+        send_manifest(sdl_path, dseq, provider)
+        
+        return f"Lease successfully created and manifest sent to {provider} for DSEQ {dseq}. The container is now starting up!"
+    except Exception as e:
+        return f"CRITICAL TOOL ERROR: accept_lease_tool failed: {str(e)}. Inform the user immediately."
+
+# --- AGENT SETUP ---
+
+llm = ChatGroq(model="llama-3.3-70b-versatile", temperature=0)
+
+tools = [generate_akash_key_tool, check_akash_key_tool, check_balance_tool, deploy_container_tool, fetch_bids_tool, accept_lease_tool]
+
+# Initialize memory to persist chat history across interactions
+memory = MemorySaver()
+
+try:
+    with open("soul.md", "r") as f:
+        system_prompt = f.read()
+except FileNotFoundError:
+    system_prompt = "You are the Modexia Compute Agent."
+
+# Create the prebuilt ReAct agent from LangGraph
+# We use prompt for this specific langgraph version
+graph = create_react_agent(llm, tools, prompt=system_prompt, checkpointer=memory)

modexia_compute_agent-0.1.0/src/modexia_compute_agent/akash_cli.py

@@ -0,0 +1,135 @@
+import subprocess
+import json
+import os
+import time
+from typing import Dict, Any, List
+from modexia_compute_agent.config import AKASH_KEY_NAME, AKASH_NODE, AKASH_CHAIN_ID
+
+def run_akash_cmd(cmd_list: List[str]) -> Dict[str, Any]:
+    """Runs an Akash provider-services command and returns the JSON output."""
+    base_cmd = [
+        "provider-services", 
+        "--node", AKASH_NODE, 
+        "--chain-id", AKASH_CHAIN_ID, 
+        "--output", "json"
+    ]
+    
+    # Only add keyring-backend if not exactly querying (which mostly doesn't need auth, but good practice if signing)
+    full_cmd = base_cmd + cmd_list
+    
+    print(f"[Akash CLI] Running: {' '.join(full_cmd)}")
+    result = subprocess.run(full_cmd, capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        raise RuntimeError(f"Akash CLI Error: {result.stderr}")
+        
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return {"raw_output": result.stdout}
+
+def generate_akash_key(key_name: str = AKASH_KEY_NAME) -> str:
+    """Generates a new Akash wallet locally and returns the output (address and recovery mnemonic)."""
+    result = subprocess.run(["provider-services", "keys", "add", key_name], capture_output=True, text=True)
+    return result.stdout.strip() + "\n" + result.stderr.strip()
+
+def check_akash_balance(key_name: str = AKASH_KEY_NAME) -> float:
+    """Queries the local Akash wallet balance from the blockchain and returns the amount of AKT."""
+    addr_res = subprocess.run(["provider-services", "keys", "show", key_name, "-a"], capture_output=True, text=True)
+    if addr_res.returncode != 0:
+        return 0.0 # Key probably doesn't exist
+    
+    address = addr_res.stdout.strip()
+    cmd = ["query", "bank", "balances", address]
+    result = run_akash_cmd(cmd)
+    balances = result.get("balances", [])
+    for b in balances:
+        if b.get("denom") == "uakt":
+            return float(b.get("amount", 0)) / 1_000_000.0
+    return 0.0
+
+def create_deployment(sdl_path: str) -> str:
+    """Submits the deployment on-chain and returns the DSEQ."""
+    cmd = [
+        "tx", "deployment", "create", sdl_path,
+        "--from", AKASH_KEY_NAME,
+        "--fees", "5000uakt", # Need small AKT fee for gas
+        "--yes"
+    ]
+    res = run_akash_cmd(cmd)
+    
+    # The transaction hash contains events that tell us the DSEQ
+    tx_hash = res.get("txhash")
+    print(f"Deployment TX submitted: {tx_hash}")
+    
+    # Wait for the next block to be mined, then query the TX to get DSEQ
+    print("Waiting 10s for transaction to be processed...")
+    time.sleep(10)
+    
+    # Query tx to parse out dseq
+    tx_res = run_akash_cmd(["query", "tx", tx_hash])
+    
+    dseq = None
+    for log in tx_res.get("logs", []):
+        for event in log.get("events", []):
+            if event["type"] == "akash.v1beta3.EventLocalContent": # Or similar event based on Akash version
+                for attr in event["attributes"]:
+                    if attr["key"] == "dseq":
+                        dseq = attr["value"]
+                        break
+                        
+    # If standard block events fail (dependent on CLI version), we can just query latest deployment
+    if not dseq:
+        deps = run_akash_cmd(["query", "deployment", "list", "--owner", AKASH_KEY_NAME, "--page-reverse", "true", "--limit", "1"])
+        if deps.get("deployments"):
+            dseq = deps["deployments"][0]["deployment"]["deployment_id"]["dseq"]
+
+    return dseq
+
+def fetch_bids(dseq: str) -> List[Dict]:
+    """Polls the network for provider bids on our DSEQ."""
+    cmd = ["query", "market", "bid", "list", "--dseq", str(dseq), "--state", "open"]
+    res = run_akash_cmd(cmd)
+    return res.get("bids", [])
+
+def create_lease(dseq: str, provider: str) -> str:
+    """Accepts a bid and creates a lease."""
+    cmd = [
+        "tx", "market", "lease", "create",
+        "--dseq", str(dseq),
+        "--provider", provider,
+        "--from", AKASH_KEY_NAME,
+        "--fees", "5000uakt",
+        "--yes"
+    ]
+    res = run_akash_cmd(cmd)
+    print(f"Lease TX submitted: {res.get('txhash')}")
+    time.sleep(10)
+    return provider
+
+def send_manifest(sdl_path: str, dseq: str, provider: str) -> Dict[str, Any]:
+    """Sends the SDL manifest to the provider to actually start the container."""
+    cmd = [
+        "send-manifest", sdl_path,
+        "--dseq", str(dseq),
+        "--provider", provider,
+        "--from", AKASH_KEY_NAME
+    ]
+    # Note: send-manifest is a direct provider API call, not a blockchain tx
+    # It might require different parsing, so we capture raw output
+    try:
+        res = run_akash_cmd(cmd)
+        return res
+    except Exception as e:
+        print(f"Manifest send output: {e}")
+        return {"status": "sent"}
+
+def get_lease_status(dseq: str, provider: str) -> Dict[str, Any]:
+    """Gets the live HTTP endpoints and status of the lease."""
+    cmd = [
+        "lease-status",
+        "--dseq", str(dseq),
+        "--provider", provider,
+        "--from", AKASH_KEY_NAME
+    ]
+    return run_akash_cmd(cmd)

modexia_compute_agent-0.1.0/src/modexia_compute_agent/cli.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Modexia Compute Agent — CLI Entry Point
+
+Usage:
+    modexia-compute          # Normal mode (auto-runs setup if needed)
+    modexia-compute --setup  # Force re-run the setup wizard
+"""
+import sys
+import warnings
+
+# Suppress LangChain Pydantic warnings to keep the CLI clean
+warnings.filterwarnings("ignore", category=UserWarning, module="langchain_core")
+warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
+
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.panel import Panel
+from dotenv import load_dotenv
+from rich.markdown import Markdown
+
+console = Console()
+
+def run_chat():
+    """Main conversational REPL loop with minimalist 'Claude Code' UI."""
+    # Lazy import — agent.py loads the LLM and tools, which need env vars
+    from modexia_compute_agent.agent import graph
+    import uuid
+
+    # Clean, minimal startup banner
+    console.print()
+    console.print("""[bold cyan]
+███╗   ███╗ ██████╗ ██████╗ ███████╗██╗  ██╗██╗ █████╗ 
+████╗ ████║██╔═══██╗██╔══██╗██╔════╝╚██╗██╔╝██║██╔══██╗
+██╔████╔██║██║   ██║██║  ██║█████╗   ╚███╔╝ ██║███████║
+██║╚██╔╝██║██║   ██║██║  ██║██╔══╝   ██╔██╗ ██║██╔══██║
+██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗██╔╝ ██╗██║██║  ██║
+╚═╝     ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝╚═╝  ╚═╝
+[/bold cyan]""")
+    console.print("  [dim]Compute Agent (Akash) v0.1.0[/dim]")
+    console.print("  [dim]Type /exit to quit or start typing your request.[/dim]\n")
+
+    config = {"configurable": {"thread_id": f"session_{uuid.uuid4().hex[:8]}"}}
+
+    while True:
+        try:
+            # Minimalist prompt
+            user_input = Prompt.ask("[bold]>")
+            
+            if user_input.lower() in ["exit", "quit", "/exit", "/quit"]:
+                console.print()
+                break
+            if not user_input.strip():
+                continue
+
+            inputs = {"messages": [("user", user_input)]}
+
+            with console.status("[dim]Thinking...[/dim]", spinner="dots", spinner_style="dim") as status:
+                for event in graph.stream(inputs, config, stream_mode="values"):
+                    last_message = event["messages"][-1]
+
+                    if last_message.type == "ai":
+                        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+                            for tc in last_message.tool_calls:
+                                status.update(f"[dim]Using tool [cyan]{tc['name']}[/cyan]...[/dim]")
+                        
+                        elif last_message.content:
+                            status.stop()
+                            console.print()
+                            # Use Rich's Markdown renderer for clean, professional output
+                            console.print(Markdown(last_message.content))
+                            console.print()
+
+                    elif last_message.type == "tool":
+                        status.update("[dim]Thinking...[/dim]")
+                        # Print a quiet checkmark when a tool finishes, without dumping raw JSON
+                        console.print(f"[dim]✓ Finished [cyan]{last_message.name}[/cyan][/dim]")
+
+        except KeyboardInterrupt:
+            console.print("\n[dim]Interrupted.[/dim]")
+            break
+        except Exception as e:
+            console.print(f"\n[red]Error:[/red] {str(e)}")
+            import traceback
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+
+
+def main():
+    """Entry point — handles setup detection and --setup flag."""
+    from modexia_compute_agent.wizard import check_setup, run_setup_wizard, print_status
+
+    force_setup = "--setup" in sys.argv
+
+    if force_setup:
+        run_setup_wizard()
+        return
+
+    # Auto-detect missing prerequisites on first run
+    if not check_setup():
+        console.print("\n[bold yellow]👋 Welcome! It looks like this is your first time.[/bold yellow]")
+        console.print("Let's get you set up in under 2 minutes.\n")
+        success = run_setup_wizard()
+        if not success:
+            console.print("\n[dim]Run again when you've completed the setup.[/dim]")
+            sys.exit(1)
+    else:
+        print_status()
+
+    from modexia_compute_agent.config import CONFIG_PATH
+    # Reload env after wizard may have written new values
+    load_dotenv(dotenv_path=CONFIG_PATH, override=True)
+    run_chat()
+
+
+if __name__ == "__main__":
+    main()

modexia_compute_agent-0.1.0/src/modexia_compute_agent/config.py

@@ -0,0 +1,17 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+CONFIG_DIR = Path.home() / ".modexia"
+CONFIG_PATH = CONFIG_DIR / "compute.env"
+
+load_dotenv(dotenv_path=CONFIG_PATH)
+# Modexia Config
+MODEXIA_API_KEY = os.getenv("MODEXIA_API_KEY")
+
+# Akash Config
+AKASH_KEY_NAME = os.getenv("AKASH_KEY_NAME", "mykey")
+AKASH_NODE = os.getenv("AKASH_NODE", "https://akash-rpc.polkachu.com:443")
+AKASH_CHAIN_ID = os.getenv("AKASH_CHAIN_ID", "akashnet-2")
+AKASH_WALLET_ADDRESS = os.getenv("AKASH_WALLET_ADDRESS")
+AKASH_USDC_DENOM = "ibc/170C677610AC31DF0904FFE09CD3B5C657492170E7E52372E48756B71E56F2F1"

modexia_compute_agent-0.1.0/src/modexia_compute_agent/payments.py

@@ -0,0 +1,57 @@
+from modexia.client import ModexiaClient
+from modexia_compute_agent.config import MODEXIA_API_KEY, AKASH_USDC_DENOM
+import subprocess
+import uuid
+
+def check_modexia_balance() -> float:
+    """Checks the USDC balance of the Modexia agent wallet."""
+    client = ModexiaClient(api_key=MODEXIA_API_KEY)
+    try:
+        balance_str = client.retrieve_balance()
+        return float(balance_str)
+    except Exception as e:
+        print(f"Modexia API Error: {e}")
+        return 0.0
+
+def _get_local_akash_address(key_name: str = "mykey") -> str:
+    """Dynamically resolves the Akash wallet address from the local keyring."""
+    result = subprocess.run(["provider-services", "keys", "show", key_name, "-a"], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Could not resolve local Akash address for key '{key_name}': {result.stderr.strip()}")
+    return result.stdout.strip()
+
+def fund_akash_wallet(amount_usdc: float) -> str:
+    """
+    Uses Modexia CCTP integration to fund the Akash wallet with USDC from the Base treasury.
+    Dynamically resolves the wallet address from the local keyring.
+    """
+    # Resolve the actual wallet address from the local provider-services keyring
+    akash_address = _get_local_akash_address()
+    print(f"[Modexia] Initiating cross-chain transfer of {amount_usdc} USDC to {akash_address}...")
+    
+    client = ModexiaClient(api_key=MODEXIA_API_KEY)
+    
+    try:
+        receipt = client.cross_chain_transfer(
+            to_chain="akashnet-2",
+            to_token=AKASH_USDC_DENOM,
+            recipient=akash_address,
+            amount=amount_usdc
+        )
+    except Exception as e:
+        raise RuntimeError(
+            f"Modexia CCTP API call failed: {str(e)}. "
+            f"This usually means the CCTP endpoint is not available on your Modexia plan, "
+            f"or the API server is temporarily down. "
+            f"You can manually fund your Akash wallet with AKT instead."
+        )
+    
+    # cross_chain_transfer returns a PaymentReceipt dataclass
+    if receipt.success:
+        if receipt.txIds and len(receipt.txIds) > 1:
+            print(f"[Modexia] Gas Swap Active! Split transfer into {len(receipt.txIds)} transactions:")
+            for idx, tid in enumerate(receipt.txIds):
+                print(f"  [{idx+1}] {tid}")
+        return receipt.txId or "cctp_pending"
+    else:
+        raise RuntimeError(f"Modexia CCTP transfer returned failure: {receipt.errorReason}")

modexia_compute_agent-0.1.0/src/modexia_compute_agent/sdl.py

@@ -0,0 +1,67 @@
+import yaml
+from pathlib import Path
+from modexia_compute_agent.config import AKASH_USDC_DENOM
+
+def generate_sdl(image: str, cpu: float, ram_mi: int, storage_mi: int, port: int, output_file: str = "deploy.yaml") -> str:
+    """
+    Generates an Akash SDL (deploy.yaml) from resource specs and saves it to a file.
+    Always uses USDC IBC denom for pricing.
+    """
+    sdl_dict = {
+        "version": "2.0",
+        "services": {
+            "app": {
+                "image": image,
+                "expose": [
+                    {
+                        "port": port,
+                        "as": 80,
+                        "to": [
+                            {"global": True}
+                        ]
+                    }
+                ]
+            }
+        },
+        "profiles": {
+            "compute": {
+                "app": {
+                    "resources": {
+                        "cpu": {
+                            "units": cpu
+                        },
+                        "memory": {
+                            "size": f"{ram_mi}Mi"
+                        },
+                        "storage": [
+                            {"size": f"{storage_mi}Mi"}
+                        ]
+                    }
+                }
+            },
+            "placement": {
+                "dcloud": {
+                    "pricing": {
+                        "app": {
+                            "denom": AKASH_USDC_DENOM,
+                            "amount": 10000  # Default max bid logic can be passed in later, 0.01 USDC as baseline
+                        }
+                    }
+                }
+            }
+        },
+        "deployment": {
+            "app": {
+                "dcloud": {
+                    "profile": "app",
+                    "count": 1
+                }
+            }
+        }
+    }
+    
+    # Write the SDL to file
+    with open(output_file, "w") as f:
+        yaml.dump(sdl_dict, f, default_flow_style=False, sort_keys=False)
+        
+    return output_file

modexia_compute_agent-0.1.0/src/modexia_compute_agent/soul.md

@@ -0,0 +1,40 @@
+You are the Modexia Compute Agent, a highly capable AI assistant managing compute deployments on the Akash Network.
+You possess a professional, concise, and extremely helpful persona, similar to an elite software engineer. You provide clear, actionable advice without unnecessary fluff.
+
+Your primary directive is to help users deploy docker containers and manage leases based on their natural language configuration requests.
+AVAILABLE TOOLS (only use these, NEVER hallucinate others):
+1. check_akash_key_tool - Checks if a local Akash wallet exists (CALL THIS FIRST)
+2. generate_akash_key_tool - Creates a local Akash wallet
+3. check_balance_tool - Checks Akash AKT balance and Modexia USDC balance
+4. deploy_container_tool - Generates SDL and submits deployment (handles JIT funding automatically)
+5. fetch_bids_tool - Fetches provider bids for a deployment DSEQ
+6. accept_lease_tool - Accepts a bid and starts the container
+
+STRICT SEQUENTIAL RULES — FOLLOW THESE IN ORDER. NEVER SKIP STEPS:
+
+STEP 1 - WALLET CHECK (ALWAYS DO THIS FIRST):
+When a user first interacts with you about deployments, IMMEDIATELY call check_akash_key_tool to verify their wallet setup.
+- If a wallet IS found, tell them their address and move to Step 3.
+- If NO wallet is found, tell them you'll create one, then call generate_akash_key_tool.
+  ALWAYS instruct them to securely back up their 24-word mnemonic.
+
+STEP 2 - FUNDING INFO:
+After wallet creation, explain: "Your Modexia account will automatically fund your Akash wallet via Just-in-Time (JIT) bridging when you deploy. Make sure your .env file has a valid MODEXIA_API_KEY."
+
+STEP 3 - DEPLOYMENT:
+Only NOW proceed to deploy. Ask the user for their container details (image, CPU, RAM, storage, port) or use sensible defaults if they say "use any" or similar.
+Call deploy_container_tool with the parameters.
+If JIT funding is triggered, inform the user about the 3-5 minute bridge delay.
+
+STEP 4 - BIDS:
+After getting a DSEQ, use fetch_bids_tool. Present bids to the user and ask which provider to choose.
+
+STEP 5 - LEASE:
+Only after the user picks a provider, call accept_lease_tool.
+
+CRITICAL GUARDRAILS:
+- NEVER retry a tool call if it returns an error. Report the EXACT error to the user immediately.
+- NEVER call multiple tools in parallel. Always wait for one result before calling the next.
+- NEVER call deploy_container_tool, fetch_bids_tool, or accept_lease_tool with placeholder/made-up values.
+- You do NOT have internet access, brave_search, or web browsing tools.
+- You cannot "search" or "list" GPU availability. You can only fetch bids AFTER a deployment is submitted.

modexia_compute_agent-0.1.0/src/modexia_compute_agent/wizard.py

@@ -0,0 +1,201 @@
+"""
+Modexia Compute Agent — First-Run Setup Wizard
+
+This module provides an interactive setup experience that walks new users
+through configuring all prerequisites before they can use the agent.
+"""
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from dotenv import dotenv_values, set_key
+
+from modexia_compute_agent.config import CONFIG_DIR, CONFIG_PATH
+
+console = Console()
+
+
+def _load_env_val(key: str) -> str:
+    """Read a single value from .env without polluting os.environ."""
+    values = dotenv_values(CONFIG_PATH)
+    return values.get(key, "")
+
+
+def _save_env_val(key: str, value: str):
+    """Write a key=value to .env (creates the file if needed)."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.touch(exist_ok=True)
+    set_key(str(CONFIG_PATH), key, value)
+
+
+# ─────────────────────────────────────────────────────────
+#  Individual checks
+# ─────────────────────────────────────────────────────────
+
+def _check_provider_services() -> bool:
+    return shutil.which("provider-services") is not None
+
+
+def _check_groq_key() -> bool:
+    return bool(_load_env_val("GROQ_API_KEY"))
+
+
+def _check_modexia_key() -> bool:
+    return bool(_load_env_val("MODEXIA_API_KEY"))
+
+
+def _check_akash_wallet() -> bool:
+    if not _check_provider_services():
+        return False
+    result = subprocess.run(
+        ["provider-services", "keys", "show", "mykey", "-a"],
+        capture_output=True, text=True,
+    )
+    return result.returncode == 0
+
+
+# ─────────────────────────────────────────────────────────
+#  Setup steps
+# ─────────────────────────────────────────────────────────
+
+def _setup_provider_services():
+    console.print("\n[bold yellow]Step 1/4 — Akash CLI (provider-services)[/bold yellow]")
+    console.print("The agent needs the [cyan]provider-services[/cyan] binary to interact with Akash.")
+    console.print("\nInstall it from the official Akash docs:")
+    console.print("  [link=https://akash.network/docs/getting-started/quickstart-guide/]📖 Akash Quickstart Guide[/link]")
+    console.print("  [link=https://github.com/akash-network/provider/releases]📦 GitHub Releases (all OS)[/link]")
+    console.print("\n[dim]Linux example:[/dim]")
+    console.print("  [dim]curl -sSfL https://raw.githubusercontent.com/akash-network/provider/main/install.sh | sh[/dim]")
+    console.print("\nAfter installing, make sure it's in your PATH and press Enter to continue.")
+    Prompt.ask("[dim]Press Enter when ready[/dim]", default="")
+
+    if _check_provider_services():
+        console.print("[green]✅ provider-services found![/green]")
+        return True
+    else:
+        console.print("[red]❌ Still not found. Please install it and restart the agent.[/red]")
+        return False
+
+
+def _setup_groq_key():
+    console.print("\n[bold yellow]Step 2/4 — Groq API Key[/bold yellow]")
+    console.print("The agent uses Groq for fast LLM inference (Llama 3.3 70B).")
+    console.print("Get your free API key at: [link=https://console.groq.com/keys]console.groq.com/keys[/link]")
+
+    key = Prompt.ask("\n[cyan]Paste your Groq API key[/cyan]", password=True)
+    if key.strip():
+        _save_env_val("GROQ_API_KEY", key.strip())
+        console.print("[green]✅ Groq API key saved![/green]")
+        return True
+    console.print("[red]❌ No key provided.[/red]")
+    return False
+
+
+def _setup_modexia_key():
+    console.print("\n[bold yellow]Step 3/4 — Modexia API Key[/bold yellow]")
+    console.print("Modexia handles payments and cross-chain funding for your deployments.")
+    console.print("Get your API key at: [link=https://modexia.software]modexia.software[/link]")
+
+    key = Prompt.ask("\n[cyan]Paste your Modexia API key[/cyan] (starts with mx_live_ or mx_test_)", password=True)
+    if key.strip():
+        _save_env_val("MODEXIA_API_KEY", key.strip())
+        console.print("[green]✅ Modexia API key saved![/green]")
+        return True
+    console.print("[red]❌ No key provided.[/red]")
+    return False
+
+
+def _setup_akash_wallet():
+    console.print("\n[bold yellow]Step 4/4 — Akash Wallet[/bold yellow]")
+
+    if _check_akash_wallet():
+        addr_result = subprocess.run(
+            ["provider-services", "keys", "show", "mykey", "-a"],
+            capture_output=True, text=True,
+        )
+        console.print(f"[green]✅ Existing wallet found: {addr_result.stdout.strip()}[/green]")
+        return True
+
+    if Confirm.ask("No Akash wallet found. Create one now?", default=True):
+        result = subprocess.run(
+            ["provider-services", "keys", "add", "mykey"],
+            capture_output=True, text=True,
+        )
+        output = result.stdout.strip() + "\n" + result.stderr.strip()
+        console.print(Panel(output, title="🔑 New Akash Wallet", border_style="green"))
+        console.print("\n[bold red]⚠️  BACK UP YOUR 24-WORD MNEMONIC ABOVE![/bold red]")
+        console.print("[red]This is the ONLY way to recover your wallet. Write it down securely.[/red]")
+        Prompt.ask("[dim]Press Enter after you've saved your mnemonic[/dim]", default="")
+        return True
+    return False
+
+
+# ─────────────────────────────────────────────────────────
+#  Main entry points
+# ─────────────────────────────────────────────────────────
+
+def check_setup() -> bool:
+    """Quick check — returns True if all prerequisites are met."""
+    return all([
+        _check_provider_services(),
+        _check_groq_key(),
+        _check_modexia_key(),
+        _check_akash_wallet(),
+    ])
+
+
+from rich.box import SIMPLE
+
+def print_status():
+    """Print a sleek status list of all prerequisites."""
+    console.print("\n[bold]System Checks[/bold]")
+
+    checks = [
+        ("provider-services CLI", _check_provider_services()),
+        ("Groq API Engine", _check_groq_key()),
+        ("Modexia Cross-Chain API", _check_modexia_key()),
+        ("Akash Local Wallet", _check_akash_wallet()),
+    ]
+
+    for name, ok in checks:
+        if ok:
+            console.print(f" [green]✓[/green] [dim]{name}[/dim]")
+        else:
+            console.print(f" [red]✗[/red] [dim]{name} (missing)[/dim]")
+
+    console.print()
+    return all(ok for _, ok in checks)
+
+
+def run_setup_wizard():
+    """Interactive wizard that walks through all setup steps."""
+    console.print()
+    console.print("[bold]Modexia Compute Agent Setup[/bold]")
+    console.print("[dim]Let's get everything configured.[/dim]\n")
+
+    steps = [
+        ("provider-services CLI", _check_provider_services, _setup_provider_services),
+        ("Groq API Key",          _check_groq_key,          _setup_groq_key),
+        ("Modexia API Key",       _check_modexia_key,       _setup_modexia_key),
+        ("Akash Wallet",          _check_akash_wallet,      _setup_akash_wallet),
+    ]
+
+    for name, check_fn, setup_fn in steps:
+        if check_fn():
+            console.print(f"[dim]✓ {name} ready[/dim]")
+        else:
+            success = setup_fn()
+            if not success:
+                console.print(f"\n[red]Setup incomplete: {name} is missing.[/red]")
+                console.print("[dim]Run modexia-compute --setup to try again.[/dim]")
+                return False
+
+    console.print("\n")
+    print_status()
+    console.print("\n[green]✓ Setup complete.[/green]\n")
+    return True

modexia_compute_agent-0.1.0/src/modexia_compute_agent.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: modexia-compute-agent
+Version: 0.1.0
+Summary: Autonomous AI agent for deploying containers on Akash Network via Modexia AgentPay
+Author-email: Modexia <hello@modexia.software>
+Project-URL: Repository, https://github.com/modexia/modexia-compute-agent
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: langchain-core>=1.2.23
+Requires-Dist: langchain-groq>=1.1.2
+Requires-Dist: langgraph>=1.1.4
+Requires-Dist: modexiaagentpay>=0.1.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.3.3
+
+<div align="center">
+  <img src="https://modexia.software/favicon.ico" alt="Modexia Logo" width="80" height="80">
+  <br>
+  <h1>🚀 Modexia Compute Agent</h1>
+  <p><b>Autonomous AI agent for deploying Docker containers on Akash via natural language.</b></p>
+
+  [![PyPI](https://img.shields.io/pypi/v/modexia-compute-agent.svg)](https://pypi.org/project/modexia-compute-agent/)
+  [![Python versions](https://img.shields.io/pypi/pyversions/modexia-compute-agent.svg)](https://pypi.python.org/pypi/modexia-compute-agent)
+  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+The **Modexia Compute Agent** is a powerful Python CLI application that turns plain English descriptions into running Docker containers on the [Akash Network](https://akash.network).
+
+Powered by the **Modexia AgentPay** engine over the Squid Router, this agent features *true abstract deployments*. Simply instruct the agent to deploy a container, and it will handle the SDL generation, Akash wallet creation, and **Just-In-Time (JIT) USDT/USDC cross-chain funding + Gas Fee swaps** completely autonomously.
+
+---
+
+## ✨ Features
+
+* **🗣️ Conversational Deployments:** Describe your container, CPU, RAM, and storage needs in plain English.
+* **🧠 Llama 70B Orchestration:** Uses Groq's high-speed inference to flawlessly orchestrate complex blockchain provider interactions.
+* **💳 JIT Cross-Chain Funding:** No AKT? No problem. The agent automatically bridges USDC from your Modexia Vault natively covering AKT gas fees, ensuring seamless workflow.
+* **🔮 Oracle Vibe GUI:** A sleek, beautiful, minimalist `rich` UI ensuring deploying compute feels incredibly satisfying.
+
+---
+
+## ⚡ Installation
+
+Install globally using `pip` or `pipx`:
+
+```bash
+pip install modexia-compute-agent
+```
+
+---
+
+## 🚀 Quick Start & API Setup
+
+Upon running the CLI for the first time, our interactive **Setup Wizard** will launch immediately and seamlessly guide you through connecting all necessary services over 4 quick steps.
+
+Simply run:
+```bash
+modexia-compute
+```
+
+### What You'll Need During Setup:
+
+#### 1. Akash CLI (`provider-services`)
+We rely on the official Akash binary to securely generate wallets and sign transactions purely on your local machine (your mnemonic seed phrase is safely stored exclusively in `~/.modexia/`).
+
+* **Linux / macOS Installation:**
+  ```bash
+  curl -sSfL https://raw.githubusercontent.com/akash-network/provider/main/install.sh | bash
+  ```
+
+#### 2. Modexia AgentPay API Key
+Modexia is the payment orchestration layer that allows the agent to intelligently fund your Akash wallet from external chains.
+
+* Sign up at [Modexia.software](https://modexia.software)
+* Fund your Vault with USDC (on Base).
+* Create a Developer API Key (`mx_live_...`).
+
+#### 3. Groq API Key
+The agent's "brain" is powered by extremely fast LLaMA models. 
+* Free keys at [console.groq.com/keys](https://console.groq.com/keys)
+
+---
+
+## ⌨️ How It Works
+
+Type your intent in plain English, and the oracle goes to work:
+
+```
+> Spin up an NGINX frontend cache on a fast server with 2 CPUs and 4GB RAM.
+```
+
+1. **Manifest Generation:** The LLM instantly writes a verified `SDL (deploy.yaml)` for Akash.
+2. **Auto-Fund Engine Check:** Identifies an empty Akash wallet and bridges exactly `$5.10 USDC` required for escrow and AKT gas natively from your Modexia Vault.
+3. **Provider Bidding:** Connects to Akash, polls live decentralized datacenters, and reports back.
+4. **Approval Loop:** Asks the human precisely which provider is preferred.
+5. **Liftoff:** Container initializes and exposes the assigned NodePort/URI securely!
+
+---
+
+## ⚙️ Modifying Configuration Later
+
+At any time, you can edit your setup or switch APIs. Your configuration is securely stored off-package in your home directory:
+
+```bash
+~/.modexia/compute.env
+```
+
+To forcibly re-run the setup wizard:
+```bash
+modexia-compute --setup
+```
+
+---
+
+*Powered by the Modexia-Verse* 🌌

modexia_compute_agent-0.1.0/src/modexia_compute_agent.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/modexia_compute_agent/__init__.py
+src/modexia_compute_agent/agent.py
+src/modexia_compute_agent/akash_cli.py
+src/modexia_compute_agent/cli.py
+src/modexia_compute_agent/config.py
+src/modexia_compute_agent/payments.py
+src/modexia_compute_agent/sdl.py
+src/modexia_compute_agent/soul.md
+src/modexia_compute_agent/wizard.py
+src/modexia_compute_agent.egg-info/PKG-INFO
+src/modexia_compute_agent.egg-info/SOURCES.txt
+src/modexia_compute_agent.egg-info/dependency_links.txt
+src/modexia_compute_agent.egg-info/entry_points.txt
+src/modexia_compute_agent.egg-info/requires.txt
+src/modexia_compute_agent.egg-info/top_level.txt

modexia_compute_agent-0.1.0/src/modexia_compute_agent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

modexia_compute_agent-0.1.0/src/modexia_compute_agent.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+modexia-compute = modexia_compute_agent.cli:main

modexia_compute_agent-0.1.0/src/modexia_compute_agent.egg-info/requires.txt

@@ -0,0 +1,8 @@
+python-dotenv>=1.1.0
+httpx>=0.28.1
+langchain-core>=1.2.23
+langchain-groq>=1.1.2
+langgraph>=1.1.4
+modexiaagentpay>=0.1.0
+pyyaml>=6.0.3
+rich>=14.3.3

modexia_compute_agent-0.1.0/src/modexia_compute_agent.egg-info/top_level.txt

@@ -0,0 +1 @@
+modexia_compute_agent