rusty

Rusty is a local-first agent system that connects iPhone voice/text input to safe Mac-side development execution with minimal latency and strong privacy guarantees. The on-device path is designed to run end-to-end without cloud for common requests: iPhone capture and transcription, FunctionGemma-based tool routing, and deterministic tool orchestration through a hardened Rust bridge. The bridge enforces token authentication, repo-root confinement, and a strict action allowlist (git_status, git_diff, run_tests, apply_patch, git_commit), while the gateway returns structured outputs, demo-friendly logs, and clear execution timelines. Its intelligent routing logic uses FunctionGemma as the default reasoning engine, escalating to Gemini only when confidence or task complexity requires cloud support. Before any escalation, a local sanitizer redacts secrets (API keys, bearer tokens, PEM blocks, .env assignments, long tokens) and emits a redaction report for auditable privacy behavior. Agentic workflows like fix_and_commit run status/diff/tests, generate compact context, propose/apply patches, retest, and commit with bounded, safe iteration. This architecture fundamentally relies on FunctionGemma plus Cactus Compute to redefine the edge-cloud frontier: fast local cognition first, selective cloud augmentation second, with security, observability, and operator control built into every step.
Technologies Used

• Rust + axum + tokio + serde/serde_json + tower-http (CORS) in mac-bridge for a hardened LAN execution API.
• FastAPI + Pydantic + httpx + uvicorn + python-dotenv + asyncio in gateway for routing, tool orchestration, and structured responses.
• SwiftUI + Foundation + Combine + URLSession in ios/rusty for the mobile control surface and API integration.
• AVFoundation (AVAudioEngine, AVAudioSession) for capture and AVSpeechSynthesizer for spoken summaries.
• Network framework (NWPathMonitor) for LAN/internet awareness and offline demo behavior.
• swift-cactus (SPM, v1.6.1) + Zip for on-device Whisper model download/cache and streaming transcription.
• FunctionGemma (via generate_hybrid loaded with importlib from functiongemma-hackathon/main.py) as the primary router/planner.
• Gemini as cloud fallback when configured (GEMINI_API_KEY) and when routing indicates escalation.

How this enables dynamic escalation

• Gateway runs generate_hybrid(messages, tools, confidence_threshold=…) and extracts routing metadata (confidence, source, decision fields).
• Local sanitizer redacts sensitive material before cloud-eligible calls, producing a redaction_report.
• If cloud is unavailable (or demo offline mode is on), the app and gateway still run local/LAN tooling and explicitly report cloud unavailability.

How this supports agentic, local-first utility

• /fix_and_commit executes a deterministic agent loop: git_status -> git_diff -> run_tests -> plan patch -> apply_patch -> retest -> git_commit.
• Safety gates include action allowlist, X-Pocket-Token, repo-root confinement, mutation confirmation, dry-run mode, iteration caps, and repeated-failure stopping.
• Local-first execution keeps common workflows fast on-device/LAN, while selective Gemini escalation adds reasoning depth only when needed.

https://github.com/adi-suresh01/functiongemma-hackathon (compute optimization, routing logic)
https://github.com/adi-suresh01/rusty (phone to mac edge ai computation with ios app)

I like working with rust