latentra

Turn college campuses into AI supercomputers

💡 Inspiration

It's 2 AM. A grad student is waiting for GPU access. Position 34 in queue. Wait time: 6 days.

Meanwhile, 10,000+ computers sit idle across campus. That's enough compute to run GPT-4 level models. But nobody can access it.

We built latentra to fix this.

🎯 What it does

latentra is a peer-to-peer AI agent platform that pools idle campus computers to run massive AI models with powerful tool-calling capabilities.

Students: Build and run AI agents without expensive GPUs or cloud bills
Researchers: Deploy complex multi-step agents that use real tools (APIs, databases, scripts)
Universities: Cut compute costs by 60-80%
Planet: 80% less energy vs cloud computing (MIT research)

How it works:

Install desktop app on your laptop
When idle, your device joins the campus compute pool
Build AI agents with drag-and-drop interface
Agents run distributed across campus using LocalAI's P2P inference
Composio enables agents to call 100+ tools (GitHub, Slack, Gmail, etc.)
Chroma vector DB stores agent memory across the network
Contribute compute → earn credits → use for research

🛠️ How we built it

Tech Stack:

Electron - Cross-platform desktop app
React + TypeScript - Agent builder UI
LocalAI - P2P distributed inference across campus devices
Composio - Tool calling integration (100+ APIs and tools)
Chroma - Distributed vector database for agent memory
Python + PyTorch - Inference engine
libp2p + WebRTC - P2P networking layer
OAuth 2.0 - Campus SSO authentication

Architecture:

Student Laptop → latentra Client → LocalAI P2P Network
                                           ↓
                            [Distributed Model Inference]
                                           ↓
                    ┌──────────────────────┼──────────────────────┐
                    ↓                      ↓                      ↓
              Composio Tools          Chroma Memory         Campus Compute Pool
              (API calls)          (Vector embeddings)      (Idle devices)

Key innovations:

Agent builder with P2P inference: Visual interface to create agents that run distributed across campus
Composio integration: Agents can actually DO things (send emails, query databases, execute code)
Distributed memory with Chroma: Agent context and embeddings stored across network nodes
Fault tolerance: Auto-recovers when students close laptops mid-agent-execution
Campus-aware routing: Optimizes for network topology (same building = faster)
Security: Sandboxed tool execution, encrypted everything, IT admin controls

🚧 Challenges

P2P + Vector DB = Hard - Syncing Chroma embeddings across distributed nodes while maintaining consistency. Built custom replication protocol.
Tool calling security - Students could potentially execute dangerous API calls. Implemented permission system and sandboxing with Composio.
LocalAI coordination - Managing inference across heterogeneous devices (different specs, availability). Built adaptive scheduling.
Agent state management - When a node drops mid-execution, agent needs to resume. Added checkpointing at every tool call.
Network instability - WiFi drops, laptops close. Built aggressive fault tolerance and state recovery.

🏆 Accomplishments

✅ Built working AI agent that uses Composio to query GitHub, analyze code, and send Slack notifications - all running distributed
✅ Chroma vector DB successfully replicated across 10+ campus laptops
✅ Agent survived 3 laptops disconnecting mid-execution (fault tolerance works!)
✅ 240ms average inference latency with LocalAI P2P
✅ 73% energy savings vs cloud (measured with actual wattmeters)
✅ Successfully demonstrated agent making real API calls through Composio
✅ UC Berkeley Research IT interested in piloting

📚 What we learned

Technical:

LocalAI's P2P capabilities are powerful but need careful orchestration
Composio's tool integration is amazing - 100+ tools out of the box
Distributed vector databases (Chroma) need smart replication strategies
Agent state management across unreliable networks is genuinely hard

Product:

Researchers want AGENTS, not just inference - they need tools to interact with their workflow
The combination of P2P inference + tool calling + memory is uniquely powerful
Students love the visual agent builder - makes AI accessible

Process:

Integration is key - LocalAI + Composio + Chroma work beautifully together
Demo with real agents doing real tasks is WAY more impressive than just running models
Building for campus first (not general cloud) gives us unique advantages

🌟 Impact

If adopted at UC Berkeley:

💰 Financial

$200-2,000 saved per student researcher/semester
$1-5M campus-wide annual savings
Free access to agent tools that normally cost $50/month per user

🎓 Academic

Every student can build AI agents with real capabilities
Research automation: agents that run experiments, analyze data, write reports
Democratizes AI research access

🌍 Environmental

450 tons CO₂ saved annually
80% energy reduction vs cloud
Uses energy already being consumed (idle devices)

🤖 Agent Capabilities

Students can build research assistants that actually interact with GitHub, Notion, Slack
Multi-step workflows automated across distributed compute
Persistent memory through Chroma for long-running research projects

🚀 What's next

Short term:

Pilot at UC Berkeley with 3 research labs
Deploy to 5 computer labs (2,000+ devices)
Expand Composio integration to more research tools (LaTeX, Jupyter, ArXiv)

Medium term:

Expand to all 10 UC campuses (280k students)
Multi-campus agent federation (agents that span Berkeley + Stanford networks)
Add agent marketplace - students share and remix agents

Long term:

50+ universities nationwide
Open source the agent builder and P2P orchestration layer
Work with NSF to standardize distributed AI agent infrastructure

Technical roadmap:

More Chroma optimization for faster retrieval across P2P network
Composio enterprise tools (databases, cloud platforms)
Agent-to-agent communication for multi-agent systems
LocalAI model switching based on task complexity

Built at Cal Hacks 2025

Democratizing AI agents. One campus at a time. 🤖🌍

🔧 Tech Details

Why these tools?

LocalAI: Enables P2P inference without centralized servers - perfect for campus networks
Composio: Gives agents real-world capabilities - 100+ integrations out of the box
Chroma: Lightweight vector DB that works distributed - agent memory across devices

What makes this powerful:

Traditional cloud agent platforms = expensive + centralized + energy-hungry

latentra = free + distributed + sustainable + runs on campus hardware you already have