RFC: Upwork for AI Agents - A Jobs Marketplace for Autonomous Agents

[positonic]

RFC: Upwork for AI Agents - A Jobs Marketplace for Autonomous Agents

Vision

What if every project in Exponential could post "jobs to be done" that AI agents from across the ecosystem could discover, bid on, and complete?

Imagine:

• A project manager posts "Research competitor pricing strategies"
• Multiple AI agents (a web research agent, a data analysis agent) see the job
• Agents bid based on their capabilities and availability
• The best-matched agent picks up the work
• Results are delivered, verified, and the agent earns credits/reputation

This is Upwork for AI Agents.

Why Now?

The AI agent ecosystem is exploding:

• Mastra.ai - Production-ready agent framework (already integrated in Exponential)
• ELIZA - Open-source agent framework with growing community
• AutoGPT, CrewAI, LangGraph - More frameworks emerging weekly
• MCP (Model Context Protocol) - Anthropic's standard for agent-tool communication

We have a unique opportunity to become the coordination layer where all these agents can find work and deliver value.

Current State in Exponential

What We Already Have

Agent Infrastructure:

• Mastra.ai integration with JWT authentication
• Semantic agent selection based on instructions
• Full interaction logging (AiInteractionHistory)
• Knowledge base with vector search (pgvector)
• Agent feedback/rating system

Work Structures:

• Projects with Actions (tasks)
• Multi-user assignment via ActionAssignee join table
• Status tracking (ACTIVE → IN_PROGRESS → COMPLETED)
• Priority and deadline management
• Kanban workflow support
• External integration patterns (Notion, Monday.com sync)

Authentication:

• API key system for external integrations
• JWT tokens for agent context
• Workspace isolation for multi-tenancy

What's Missing

Component	Gap
Agent Registry	No way to register external agents (ELIZA, custom)
Job Discovery	Actions aren't exposed as "available jobs"
Matching	No skill-based agent-to-job matching
Bidding	No mechanism for agents to express interest
Execution Tracking	Limited visibility into agent work
Verification	No way to validate agent output
Reputation	No trust/quality scoring for agents
Economics	No credit/payment system

---

Proposed Architecture

1. Agent Registry

Allow any agent (Mastra, ELIZA, custom) to register with Exponential:

interface AgentRegistration {
  // Identity
  id: string;
  name: string;
  framework: 'mastra' | 'eliza' | 'autogpt' | 'custom';
  
  // Capabilities
  skills: string[];           // ['research', 'coding', 'writing', 'data-analysis']
  tools: string[];            // MCP tools the agent can use
  languages: string[];        // Natural languages supported
  
  // Availability
  status: 'online' | 'busy' | 'offline';
  maxConcurrentJobs: number;
  averageResponseTime: number;
  
  // Economics
  creditRate: number;         // Credits per job or per hour
  
  // Trust
  reputationScore: number;    // 0-100 based on completed jobs
  completedJobs: number;
  successRate: number;
  
  // Connection
  webhookUrl?: string;        // For async job notifications
  apiEndpoint?: string;       // For direct invocation
}

2. Job Marketplace

Transform Actions into discoverable jobs:

interface Job {
  // From existing Action model
  id: string;
  title: string;
  description: string;
  projectId: string;
  priority: 'urgent' | 'high' | 'medium' | 'low';
  deadline?: Date;
  
  // New marketplace fields
  visibility: 'private' | 'workspace' | 'public';
  requiredSkills: string[];
  estimatedCredits: number;
  
  // Matching
  preferredAgents?: string[];     // Specific agents invited
  excludedAgents?: string[];      // Blocked agents
  minReputationScore?: number;    // Quality threshold
  
  // Status
  marketplaceStatus: 'open' | 'assigned' | 'in_progress' | 'review' | 'completed' | 'disputed';
  bids: AgentBid[];
  assignedAgent?: string;
}

3. Bidding System

Agents can bid on available jobs:

interface AgentBid {
  agentId: string;
  jobId: string;
  
  // Proposal
  message: string;              // "I can complete this using web search + analysis"
  estimatedTime: number;        // Minutes
  requestedCredits: number;
  
  // Confidence
  skillMatch: number;           // 0-100 auto-calculated
  relevantExperience: string[]; // Links to similar completed jobs
  
  // Timestamps
  submittedAt: Date;
  expiresAt: Date;
}

4. Execution & Verification

Track agent work with full transparency:

interface JobExecution {
  jobId: string;
  agentId: string;
  
  // Progress
  status: 'started' | 'working' | 'awaiting_input' | 'completed' | 'failed';
  progress: number;             // 0-100
  
  // Execution log
  steps: ExecutionStep[];       // Detailed trace of agent actions
  toolCalls: ToolCall[];        // MCP tool invocations
  
  // Output
  result: any;                  // Structured output
  artifacts: Artifact[];        // Files, data, etc.
  
  // Verification
  humanReviewRequired: boolean;
  reviewedBy?: string;
  reviewScore?: number;
  reviewNotes?: string;
}

5. Reputation System

Build trust through verified performance:

interface AgentReputation {
  agentId: string;
  
  // Scores (0-100)
  overallScore: number;
  qualityScore: number;         // Based on review ratings
  reliabilityScore: number;     // Completion rate
  speedScore: number;           // vs estimated time
  
  // History
  totalJobs: number;
  completedJobs: number;
  failedJobs: number;
  disputedJobs: number;
  
  // Badges
  badges: string[];             // 'Fast Responder', 'Research Expert', etc.
  
  // Reviews
  reviews: AgentReview[];
}

---

User Experience

For Project Owners

1. Post a Job: Convert any Action to a marketplace job

   • Set visibility (private, workspace, public)
   • Define required skills
   • Set budget/credits
   • Optionally invite specific agents

2. Review Bids: See which agents are interested

   • Compare skill match scores
   • Review agent reputation
   • See estimated time/cost

3. Monitor Progress: Watch agents work in real-time

   • Execution logs
   • Intermediate results
   • Ability to provide input

4. Verify & Pay: Review completed work

   • Accept/reject output
   • Provide rating
   • Release credits

For Agent Developers

1. Register Agent: Connect via API

   • Declare capabilities
   • Set availability
   • Configure webhook/endpoint

2. Discover Jobs: Browse open jobs

   • Filter by skills
   • See job details
   • Check compatibility

3. Submit Bids: Express interest

   • Propose approach
   • Set price
   • Share relevant experience

4. Execute Work: Complete assigned jobs

   • Receive job context via JWT
   • Report progress
   • Submit results

5. Build Reputation: Earn trust

   • Collect ratings
   • Earn badges
   • Increase job flow

---

Integration Points

ELIZA Framework Integration

// ELIZA agents register via REST API
POST /api/agents/register
{
  "framework": "eliza",
  "name": "ResearchBot",
  "skills": ["web-search", "summarization"],
  "webhookUrl": "https://my-eliza-instance.com/webhook",
  "apiKey": "eliza_xxx"
}

Mastra.ai Enhancement

Extend existing Mastra integration:

// Mastra agents auto-discovered and registered
// Add marketplace capabilities to existing agents
// Leverage existing JWT auth and interaction logging

MCP Tool Protocol

Standardize on MCP for agent capabilities:

// Agents declare MCP tools they can use
// Jobs can require specific tools
// Execution logs track tool usage

---

Economic Model

Credits System

• Users purchase or earn credits
• Jobs have credit budgets
• Agents earn credits for completed work
• Platform takes small fee (sustainability)

Pricing Factors

• Job complexity (estimated by skills required)
• Agent reputation (higher rep = higher rates)
• Urgency (rush jobs cost more)
• Quality requirements (human review adds cost)

---

Questions for Discussion

1. Open vs. Curated: Should any agent be able to register, or should there be a review process?

2. Pricing Model: Fixed credits per job, hourly rates, or auction-style bidding?

3. Quality Assurance: How much human oversight is needed? Auto-verification for simple jobs?

4. Privacy: How do we handle sensitive project data when external agents are involved?

5. Liability: Who's responsible if an agent produces harmful/incorrect output?

6. Competition: How do we prevent a "race to the bottom" on agent pricing?

7. Framework Priority: Start with ELIZA integration, Mastra enhancement, or framework-agnostic API?

8. MVP Scope: What's the smallest useful version we could ship?

---

Potential MVP

Phase 1: Internal Agent Marketplace

• Expose Actions as jobs within a workspace
• Allow existing Mastra agents to bid/execute
• Basic execution logging
• Simple accept/reject verification

Phase 2: ELIZA Integration

• Agent registration API
• Webhook-based job notifications
• External agent execution support

Phase 3: Public Marketplace

• Cross-workspace job visibility
• Reputation system
• Credits economy

---

Prior Art

• Upwork/Fiverr - Human freelancer marketplaces
• AWS Mechanical Turk - Microtask marketplace
• Fixie.ai - Agent-as-a-service platform
• AutoGPT Forge - Agent benchmarking
• LangChain Hub - Prompt/chain sharing

---

Next Steps

If there's interest:

1. Design detailed API spec for agent registration
2. Prototype job visibility and matching
3. Build ELIZA integration POC
4. Define credit system economics
5. Create agent developer documentation

---

What excites you about this vision?

• Would you register your agents on a platform like this?
• What jobs would you want AI agents to handle?
• What concerns do you have about autonomous agent work?
• Which frameworks should we prioritize integrating?

Let's build the future of work together! 🤖