EasyRemote is not just a Private Function-as-a-Service (Private FaaS) platform—it's our answer to the future of computing:

While current cloud computing models are platform-centric, requiring data and code to "go to the cloud" to exchange resources, we believe: The next-generation computing network should be terminal-centric, language-interfaced, function-granular, and trust-bounded.

We call it: "EasyNet".

EasyRemote is the first-stage implementation of EasyNet, allowing you to:

• 🧠 Define task logic using familiar Python function structures
• 🔒 Deploy computing nodes on any device while maintaining privacy, performance, and control
• 🌐 Transform local functions into globally accessible task interfaces through lightweight VPS gateways
• 🚀 Launch tasks as simply as using torchrun, automatically scheduling to the most suitable resources for execution

# 1. Start gateway node (any VPS)
from easyremote import Server
Server(port=8080).start()

# 2. Contribute computing node (your device)
from easyremote import ComputeNode
node = ComputeNode("your-gateway:8080")

@node.register
def ai_inference(prompt):
    return your_local_model.generate(prompt)  # Runs on your GPU

node.serve()

# 3. Global computing access (anywhere)
from easyremote import Client
result = Client("your-gateway:8080").execute("ai_inference", "Hello AI")

🎉 Your device has joined EasyNet!

EasyRemote is purpose-built for the AI era. Beyond general distributed computing, it directly addresses the pain points AI teams face today:

• GPU Isolation: Team GPUs sit idle 80% of the time, yet cloud inference costs $200+/million calls
• Data Can't Leave: Healthcare, finance, and government data must stay on-premise, but AI models live in the cloud
• Agent Integration Is Fragmented: Connecting AI agents to real tools requires custom glue code for every service
• Cold Starts Kill UX: Cloud functions take 100-1000ms to wake up, destroying real-time AI experiences

EasyRemote speaks the languages AI agents already understand — MCP and A2A:

MCP (Model Context Protocol) — AI agents (Claude, etc.) discover and invoke your functions as tools:

# Your compute node registers functions as usual
@node.register(description="Summarize text using local LLM")
def summarize(text: str) -> str:
    return local_llm.summarize(text)

# Agents discover via MCP:  POST /mcp {"method": "tools/list"}
# Agents invoke via MCP:    POST /mcp {"method": "tools/call", "params": {"name": "summarize", ...}}

Supported: initialize, tools/list, tools/call, ping, batch requests, notifications, JSON-RPC 2.0

A2A (Agent-to-Agent Protocol) — Agents coordinate through standardized task execution:

# Agent discovers:  POST /a2a {"method": "agent.capabilities"}
# Agent executes:   POST /a2a {"method": "task.execute", "params": {"task": {...}}}
# Agent notifies:   POST /a2a {"method": "task.send", "params": {...}}

Supported: agent.capabilities, task.execute, task.send, ping, task ID fallback, batch requests

EasyRemoteClientRuntime — Agent-side proxy that bridges MCP/A2A to EasyRemote's distributed gateway:

from easyremote.protocols import EasyRemoteClientRuntime
runtime = EasyRemoteClientRuntime(gateway="your-gateway:8080")
# Exposes real gateway functions as MCP tools / A2A capabilities
# Supports node_id targeting, load_balancing, and streaming

• 📖 English Documentation Center - Complete English documentation navigation

• 📖 中文文档中心 - Complete Chinese documentation navigation

• 5-Minute Quick Start - Fastest way to get started | 中文
• Installation Guide - Detailed installation instructions | 中文

• Examples - Core runnable examples | 中文
• Business Use Cases & Route Layers - Current vs roadmap (MCP/A2A and decorator paths)
• Killer Apps Gallery - Real-world use-case catalog with flagship applications
• Gallery Projects - Quickstart project templates restored from removed demos

• MCP Implemented Scope - Current protocol behavior and limits
• A2A Implemented Scope - Current protocol behavior and limits
• Agent-side Gateway Proxy Runtime - EasyRemoteClientRuntime (see MCP/A2A guides section 2.3)
• Capability Management Protocol (CMP) - Skill/ability CRUD on user nodes (install/uninstall/list)

• Technical Whitepaper - EasyNet theoretical foundation | 中文
• Research Proposal - Academic research plan | 中文
• Project Pitch - Business plan overview | 中文

@node.register
def medical_diagnosis(scan_data):
    # Medical data never leaves your HIPAA-compliant device
    # But diagnostic services can be securely accessed globally
    return your_private_ai_model.diagnose(scan_data)

• Traditional Cloud Services: Pay-per-use, costs increase exponentially with scale
• EasyNet Model: Contribute computing power to earn credits, use credits to call others' computing power
• Gateway Cost: $5/month vs traditional cloud $200+/million calls

# Your gaming PC can provide AI inference services globally
@node.register
def image_generation(prompt):
    return your_stable_diffusion.generate(prompt)

# Your MacBook can participate in distributed training
@node.register  
def gradient_computation(batch_data):
    return your_local_model.compute_gradients(batch_data)

"Computing Evolution is not linear progression, but paradigmatic leaps"

Core Innovation: From local calls → cross-node function calls Technical Expression: @remote decorator for transparent distributed execution Paradigm Analogy: RPC → gRPC → EasyRemote (spatial decoupling of function calls)

# Traditional local calls
def ai_inference(data): return model.predict(data)

# EasyRemote: Function calls across global networks
@node.register  
def ai_inference(data): return model.predict(data)
result = client.execute("global_node.ai_inference", data)

Breakthrough Metrics:

• API Simplicity: 25+ lines → 12 lines (-52%)
• Startup Latency: 100-1000ms → 0ms (-100%)
• Privacy Protection: Data to cloud → Never leaves local

Core Innovation: From explicit scheduling → adaptive intelligent scheduling Technical Expression: Intent-driven multi-objective optimization scheduling Paradigm Analogy: Kubernetes → Ray → EasyRemote ComputePool

# Traditional explicit scheduling
client.execute("specific_node.specific_function", data)

# EasyRemote: Intelligent intent scheduling
result = await compute_pool.execute_optimized(
    task_intent="image_classification",
    requirements=TaskRequirements(accuracy=">95%", cost="<$5")
)
# System automatically: task analysis → resource matching → optimal scheduling

Breakthrough Metrics:

• Scheduling Efficiency: Manual config → Millisecond auto-decisions
• Resource Utilization: 60% → 85% (+42%)
• Cognitive Load: Complex config → Intent expression

Core Innovation: From calling functions → expressing intentions Technical Expression: Natural language-driven expert collaboration networks Paradigm Analogy: LangChain → AutoGPT → EasyRemote Intent Engine

# Traditional function call mindset
await compute_pool.execute_optimized(function="train_classifier", ...)

# EasyRemote: Natural language intent expression
result = await easynet.fulfill_intent(
    "Train a medical imaging AI with >90% accuracy for under $10"
)
# System automatically: intent understanding → task decomposition → expert discovery → collaborative execution

Breakthrough Metrics:

• User Barrier: Python developers → General users (10M+ user scale)
• Interaction Mode: Code calls → Natural language
• Collaboration Depth: Tool calls → Intelligent agent networks

┌────────────────────────────────────────────────────────────┐
│                 Global Compute OS                          │ ← Paradigm 3: Intent Layer
│    "Train medical AI" → Auto-coordinate global experts     │   (Intent-Graph)
└────────────────────────────────────────────────────────────┘
                            ▲
┌────────────────────────────────────────────────────────────┐
│              Compute Sharing Platform                      │ ← Paradigm 2: Autonomous Layer  
│    Intelligent scheduling + Multi-objective optimization   │   (Intelligence-Linked)
└────────────────────────────────────────────────────────────┘
                            ▲
┌────────────────────────────────────────────────────────────┐
│               Private Function Network                      │ ← Paradigm 1: Function Layer
│    @remote decorator + Cross-node calls + Load balancing   │   (Function-Driven)  
└────────────────────────────────────────────────────────────┘

Ultimate Vision: Mobilize global computing as easily as using torchrun

$ easynet "Train a medical imaging AI with my local data, 95%+ accuracy required"
🤖 Understanding your needs, coordinating global medical AI expert nodes...
✅ Found stanford-medical-ai and 3 other expert nodes, starting collaborative training...

🤖 AI Agents (MCP/A2A)    🌍 Human Clients (Decorator/@remote)
         \                      /
          v                    v
   ☁️ Lightweight gateway cluster (routing + protocol adaptation, no computing)
                    ↓
        💻 Personal computing nodes (actual GPU/CPU execution)
                    ↓
           🔗 Peer-to-peer collaboration network

• Communication Protocol: gRPC + Protocol Buffers
• Secure Transport: End-to-end encryption
• Load Balancing: Intelligent resource awareness
• Fault Tolerance: Automatic retry and recovery

Limitations of Traditional Models:

• 💸 Cloud service costs grow exponentially with scale
• 🔒 Data must be uploaded to third-party servers
• ⚡ Cold starts and network latency limit performance
• 🏢 Locked into major cloud service providers

EasyNet's Breakthroughs:

• 💰 Computing Sharing Economy: Contribute idle resources, gain global computing power
• 🔐 Privacy by Design: Data never leaves your device
• 🌐 Decentralized: No single points of failure, no vendor lock-in

Redefining the future of computing: From a few cloud providers monopolizing computing power to every device being part of the computing network.

# Become an early node in EasyNet
pip install easyremote

# Contribute your computing power
python -c "
from easyremote import ComputeNode
node = ComputeNode('demo.easynet.io:8080')
@node.register
def hello_world(): return 'Hello from my device!'
node.serve()
"

• Technical Discussions: GitHub Issues
• Community Chat: GitHub Discussions
• Business Collaboration: silan.hu@u.nus.edu
• Project Founder: Silan Hu - NUS PhD Candidate

pip install easyremote