Everything you need to know about MicroDC.ai
Information for CEOs, CFOs, and business decision-makers evaluating MicroDC.ai for their organization.
AI inference is the process of using a trained AI model to generate outputs from new inputs. Think of it as "running" the AI to get answers, summaries, or predictions.
If training an AI is like teaching a student (expensive, time-consuming), then inference is like asking that student questions after they've graduated (quick, but still requires resources).
Examples of AI inference:
Why it's expensive: AI inference requires powerful GPU hardware. Every time you use ChatGPT, Claude, or similar services, GPUs are working behind the scenes. At scale, these costs add up quickly - which is exactly the problem MicroDC solves.
Bottom line: If your business needs to process text, documents, or data using AI at scale, you're paying for inference. MicroDC helps you pay up to 90% less.
MicroDC.ai is a distributed AI inference platform that operates as a two-sided marketplace, connecting businesses that need AI compute power with individuals and organizations that have idle GPU resources.
The Problem: AI inference costs are skyrocketing. Major cloud providers charge premium prices for GPU instances, and building internal infrastructure requires significant capital expenditure and technical expertise.
Our Solution: We aggregate distributed GPU resources from around the world, providing enterprise-grade AI inference at up to 90% lower cost than traditional cloud providers, with no infrastructure management required.
MicroDC was founded by Ray Sisson (CEO) and Jeffrey Rivero (CTO), with Neil Quarterman serving as CFO.
| Factor | MicroDC | Major Cloud Providers |
|---|---|---|
| Business Model | Marketplace (asset-light) | Infrastructure owner (asset-heavy) |
| Cost Savings | Up to 90% lower | Premium pricing |
| Processing Model | Asynchronous batch | Real-time (expensive) |
| Minimum Commitment | Pay-per-use, no minimum | Often requires commitments |
| Setup Time | Minutes | Hours to days |
Organizations typically see 50-90% cost reduction compared to traditional cloud GPU instances:
Example: A document processing company processing 100,000 documents/month saved 78% by switching from dedicated GPU instances to MicroDC's batch processing.
MicroDC excels at workloads that don't require sub-second real-time responses:
We use a simple, transparent credit-based system:
Pricing Tiers:
Security is foundational to our architecture. Our CTO is CISSP-certified with 25+ years in cybersecurity:
Current Security Posture:
Planned Certifications (Roadmap):
Contact us for detailed security documentation and our current compliance status.
We recommend the following approach for sensitive data:
For HIPAA, PCI-DSS, or other regulated workloads, please contact our sales team to discuss dedicated infrastructure options.
Yes, we offer customized enterprise packages including:
Contact sales@microdc.ai to discuss enterprise options.
Platform Availability: 99.9% API uptime target
Job Processing SLA: Varies by priority tier
Enterprise customers receive customized SLAs with credits for missed targets.
Organizations with idle GPU capacity can monetize their infrastructure:
Contact us to discuss becoming a GPU provider partner.
We are developing blockchain integration to enhance transparency, trust, and decentralized payments:
Blockchain integration is on our roadmap. Traditional payment methods will remain available for organizations preferring conventional finance.
Core Platform
Batch inference, 100+ models, credit system, web dashboard
Enhanced Capabilities
Streaming responses, custom model hosting, enhanced analytics
Blockchain & Scale
On-chain verification, token payments, global expansion
Technical details for engineers and developers building with MicroDC.ai.
MicroDC uses a three-component distributed architecture:
Client (SDK/API) Server (Hub) Workers (Compute)
| | |
| Submit Job | |
|------------------>| |
| | Queue Job |
| |-------------------->|
| | |
| | Poll for Jobs |
| |<--------------------|
| | |
| | Return Results |
| |<--------------------|
| Get Results | |
|<------------------| |
Key Components:
The scheduler uses intelligent matching to optimize job distribution:
Smart Retry: If a job fails on a worker, it will not be reassigned to the same worker to prevent repeated failures.
Install the SDK and submit jobs with just a few lines:
# Install
pip install git+https://gitlab.com/microdc/python-client.git
# Submit a job
from microdc import Client, LLMCall
client = Client(api_key="mDC_your_api_key")
# Create an LLM job
job = LLMCall(model="llama3.3")
job.add_user_message("Explain quantum computing in simple terms")
# Submit and wait for result
job_id = client.send_job(job)
result = client.wait_for_job(job_id)
print(result.output)
Core API endpoints (base URL: https://console.microdc.ai/api/v1):
| Method | Endpoint | Description |
|---|---|---|
| POST | /jobs | Submit a new job |
| GET | /jobs/{job_id} | Get job status/result |
| GET | /jobs | List your jobs |
| GET | /models | List available models |
| GET | /account/balance | Check credit balance |
| DELETE | /jobs/{job_id} | Cancel a pending job |
Authentication: Include header Authorization: Bearer mDC_your_api_key
Text generation and chat completions
Text embeddings for search/RAG
AI image creation
Flexible custom workloads
You can receive job completion notifications via webhooks:
# Submit job with callback URL
job = LLMCall(model="llama3.3")
job.add_user_message("Process this document...")
job_id = client.send_job(
job,
callback_url="https://your-api.com/webhook/microdc"
)
# Your webhook will receive:
# POST https://your-api.com/webhook/microdc
# {
# "job_id": "uuid",
# "status": "completed",
# "result": { ... }
# }
Alternatively, use polling with client.wait_for_job(job_id)
We support 100+ open-source models including:
Yes! Custom model hosting is available:
Contact us for custom model hosting requirements and pricing.
Job completion times depend on several factors:
| Factor | Impact |
|---|---|
| Priority Tier | Premium < Standard < Economy |
| Model Size | 7B faster than 70B |
| Token Count | More tokens = longer processing |
| Queue Depth | Varies by network load |
Typical Times: Most jobs complete within 30 seconds to 5 minutes. Premium tier averages under 1 minute.
We use API keys for SDK/API authentication:
# Environment variable (recommended)
export MICRODC_API_KEY="mDC_your_api_key_here"
# In code
client = Client() # Auto-reads from env
# Or explicitly
client = Client(api_key="mDC_...")
# HTTP Header
Authorization: Bearer mDC_your_api_key
Best Practice: Never commit API keys to version control. Use environment variables or secrets management.
Default rate limits (can be increased for enterprise):
| Job submissions | 100/minute |
| Status checks | 300/minute |
| Concurrent jobs | 50 (default) |
| Burst allowance | 2x for 10 seconds |
Rate limit headers included in responses: X-RateLimit-Remaining
Minimum requirements:
| Component | Minimum | Recommended |
|---|---|---|
| GPU | NVIDIA GTX 1060 6GB | RTX 3080+ / A100 |
| VRAM | 6GB | 16GB+ |
| RAM | 16GB | 32GB+ |
| Storage | 100GB SSD | 500GB+ NVMe |
| Internet | 50 Mbps | 100+ Mbps |
AMD GPUs (ROCm) also supported. CPU-only workers can handle smaller models.
Quick setup (5 minutes):
# 1. Clone the worker repository
git clone https://gitlab.com/microdc/worker.git
cd worker
# 2. Install dependencies
pip install -r requirements.txt
# 3. Configure with your registration token
export MICRODC_WORKER_TOKEN="mdc_wrk_your_token"
# 4. Start the worker
python worker.py --models llama3-8b,mistral-7b
# Worker will automatically:
# - Register with the server
# - Download required models
# - Start polling for jobs
Workers receive 70% of the job price (industry-leading):
Example Calculation:
Factors affecting earnings:
We're evaluating several blockchain platforms for our integration:
Final blockchain selection will be announced as we approach launch.
Smart contracts will automate several platform functions:
Job payment locked in escrow, released to worker on verified completion
Cryptographic verification that inference was performed correctly
On-chain reputation scores for workers based on performance
Decentralized arbitration for contested job completions
We're exploring a utility token model with the following potential features:
Note: Token economics are under development. Traditional fiat payments will always be supported alongside any token implementation.
Planned hybrid architecture:
Off-Chain (Speed) On-Chain (Trust)
| |
Job Submission |
| |
Job Execution |
| |
Result Delivery |
| |
+--- Settlement ---------->| Payment Record
| | Proof of Work
+--- Disputes ------------>| Arbitration
| | Reputation Update
Key Design Principles:
Blockchain integration is on our roadmap with a phased approach:
Crypto Payments
Accept stablecoin payments (USDC, USDT)
On-Chain Verification
Job completion proofs on-chain
Full Decentralization
Token launch, staking, governance
Sign up for our newsletter to stay updated on blockchain developments.
Our team is here to help. Reach out for personalized assistance with your specific use case.