Skip to main content

​
Architecture Overview

JARVIS uses a distributed deployment architecture optimized for hackathon development and production scalability. 
┌──────────────────────────────────────┐
│  Vercel                               │
│  - Next.js frontend (corkboard)      │
│  - API routes (capture endpoint)     │
└──────────────────┬───────────────────┘
                   │
┌──────────────────┼───────────────────┐
│  Daytona Sandbox(es)                  │
│  - Python backend (FastAPI)          │
│  - Browser Use agents (headless)     │
│  - PimEyes automation                │
│  - Agent orchestrator                │
└──────────────────┬───────────────────┘
                   │
┌──────────────────┼───────────────────┐
│  Managed Services                     │
│  - Convex (real-time DB)             │
│  - MongoDB Atlas (persistent)        │
│  - Laminar (observability)           │
│  - Exa API (research)               │
│  - OpenAI API (vision + synthesis)   │
│  - Google Gemini API (synthesis)     │
└──────────────────────────────────────┘

​
Deployment Strategy

​
Frontend Deployment

Platform: Vercel
Repository: Connect your Git repository
Build Command: npm run build
Output Directory: .next Vercel provides:
  • Automatic deployments on git push
  • Preview deployments for pull requests
  • Edge network CDN
  • Zero-config Next.js optimization

​
Backend Deployment

Platform: Daytona Sandboxes
Runtime: Python 3.11
Framework: FastAPI + Uvicorn Daytona provides:
  • Isolated browser sessions for agents
  • Persistent workspace environments
  • Built-in proxy for external access
  • Resource isolation per sandbox

​
Service Dependencies

ServicePurposeDeployment
ConvexReal-time databaseManaged cloud
MongoDB AtlasPersistent storageManaged cloud
Exa APIFast researchExternal API
Browser UseAgent automationCloud sessions
Gemini APIVision + synthesisGoogle Cloud
OpenAI APIVision modelsOpenAI Cloud
LaminarObservabilityManaged cloud

​
Deployment Checklist

1

Configure Environment Variables

Set up all required environment variables in both frontend and backend environments. See Environment Variables for complete list.
2

Deploy Backend

Deploy the Python backend to Daytona sandboxes with Docker. See Backend Deployment for detailed steps.
3

Deploy Frontend

Deploy the Next.js frontend to Vercel. See Frontend Deployment for detailed steps.
4

Verify Services

Test all service integrations and verify observability traces.

​
Resource Requirements

​
Backend (Daytona Sandbox)

  • CPU: 2-4 cores recommended
  • RAM: 4GB minimum, 8GB recommended
  • Storage: 10GB for browser cache and temporary files
  • Network: High bandwidth for browser automation

​
Frontend (Vercel)

  • Build Time: ~2-3 minutes
  • Cold Start: Less than 100ms (serverless functions)
  • Edge Functions: Deployed globally

​
Monitoring & Observability

The platform includes comprehensive observability through Laminar:
  • Agent Tracing: Every Browser Use agent run is traced
  • LLM Calls: All Gemini/OpenAI calls logged with inputs/outputs
  • Performance Metrics: Response times, error rates, success rates
  • Debug Dashboard: Real-time view of active agents and pipelines

​
Security Considerations

Never commit API keys or sensitive credentials to version control. Always use environment variables.

​
API Key Management

  • Store all API keys as environment variables
  • Rotate credentials regularly
  • Use separate keys for development and production
  • Monitor API usage for anomalies

​
Network Security

  • Backend is isolated in Daytona sandboxes
  • Frontend communicates via HTTPS only
  • CORS configured for allowed origins
  • Rate limiting on API endpoints

​
Scaling Considerations

​
Horizontal Scaling

  • Frontend: Automatically scaled by Vercel
  • Backend: Deploy multiple Daytona sandboxes behind load balancer
  • Database: Convex and MongoDB Atlas handle scaling automatically

​
Performance Optimization

  • Pre-warm browser sessions for faster agent startup
  • Cache common profile templates
  • Use connection pooling for MongoDB
  • Implement request queuing for rate-limited APIs

​
Cost Estimation

ComponentFree TierPaid Tier
VercelUnlimited hobby projects$20/mo Pro
Daytona$100 hackathon creditsPay-as-you-go
ConvexGenerous free tierUsage-based
MongoDB Atlas512MB free$9/mo+
Browser Use$100 hackathon creditsUsage-based
Gemini API$20 creditsPay-per-token
Laminar$150 hackathon creditsUsage-based
Hackathon Total: 370increditsavailable∗∗ProductionEstimate:∗∗370 in credits available **Production Estimate:** 50-200/month depending on usage

​
Next Steps

Backend Setup

Deploy the FastAPI backend to Daytona

Frontend Setup

Deploy the Next.js frontend to Vercel

Environment Vars

Configure all required environment variables

Build docs developers (and LLMs) love

Get started for freeTalk to us