Skip to content

Empowering smart app development with SolidGPT: an edge-cloud hybrid AI agent framework

🕒 Published (v1): 2025-12-09 06:34 UTC · Source: Arxiv · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

SolidGPT is an open-source, edge–cloud hybrid developer assistant that routes LLM tasks between on-device and cloud models using an MDP-based mechanism, combined with semantic code embeddings and a sequential multi-agent pipeline (PM→PE→SDE) to automate software project workflows while preserving data privacy.

Problem

Cloud-only LLM developer tools suffer from latency (mean 2.4s RTT), data privacy risks (GDPR/HIPAA exposure), and energy costs; edge-only models lack the contextual depth to handle cross-module code reasoning. No existing tool bridges these trade-offs while maintaining context continuity across local/cloud execution boundaries or integrating natively with mobile-specific architectures (Android MVVM, Kotlin coroutines).

Method

Three-layer hybrid architecture: 1. MDP routing: Real-time assessment of contextual complexity, device GPU presence, and network latency determines whether a query is handled on-device or delegated to a cloud LLM (e.g., GPT-4). 2. Sequential multi-agent pipeline: PM Agent (requirements → PRD), PE Agent (PRD → design doc + task decomposition, synced to Notion), SDE Agent (design → scaffolded code via Lowdefy or custom generators); each stage is human-reviewable before passing output downstream. 3. Semantic alignment subsystem: AST-based 768-dim code embeddings stored in a vector DB; ConstraintLayout→natural-language conversion (rule-based, 98.2% accuracy); transformer attention fusion weighting IDE interactions (α=0.63), code context (α=0.27), and runtime logs (α=0.10).

Additionally, a VSCode plugin intercepts IDE events and propagates them to the inference engine for real-time MVVM-aware analysis.

Key Contributions

  • MDP-driven adaptive routing between edge and cloud models based on runtime task complexity and device state.
  • Three-agent sequential pipeline (PM/PE/SDE) with human-in-the-loop approval at each stage.
  • Context-retentive prompt engineering using AST-graph embeddings and attention-based fusion to prevent context fragmentation across edge/cloud handoffs.
  • MVVM integration layer that binds XML layouts, Kotlin coroutine flows, and TensorFlow Lite outputs for real-time semantic feedback in Android development.
  • Local-first deployment via Docker/VSCode extension with optional cloud LLM API calls; private codebase onboarding up to ~500 files.

Results

Validated on a 12-week deployment on a 128,500-LOC Android app with 43 developers across 6 teams: - Median bug resolution time: 142 min → 51 min (64% reduction, p < 0.001). - Cloud API requests reduced by 56.3%. - Sub-second response for 87% of developer queries. - 91% accuracy in automated crash diagnostics (vs. 68% F1 for rule-based tools like BugSwarm). - UI-related bugs reduced by 62.3% via MVVM real-time feedback. - 32% improvement in suggestion relevance over static prompting (p < 0.01). - 23.4% reduction in context-switching overhead.

No external baseline system was directly compared head-to-head in a controlled ablation; comparisons are descriptive against cited prior tools.

Limitations

  • Evaluation is a single-app, single-organization deployment; no controlled ablation separating contributions of routing, multi-agent pipeline, or embedding subsystem.
  • Private codebase onboarding capped at ~500 files, limiting scalability to large monorepos.
  • MDP routing mechanism is described conceptually but no training procedure, state/action space, or reward function details are provided.
  • Reported numbers (62.3% UI bug reduction, 98.2% UI mapping accuracy) lack methodology details or independent replication.
  • Mobile-specific focus (Android MVVM, Kotlin) limits generalizability; iOS/SwiftUI support is not demonstrated.
  • Reference list contains a tangentially related dental AI paper ([5]) and a GitHub repo ([1]) as primary citations, indicating thin peer-reviewed grounding.

Relevance to Harnesses / Meta-Harnesses

SolidGPT is a concrete example of a meta-harness: it orchestrates multiple specialized agents (PM, PE, SDE) in a fixed sequential pipeline where each agent's output is the next agent's input, with human checkpoints between stages—the defining structure of a harness. The MDP-based routing layer acts as a dynamic dispatcher, a pattern directly analogous to meta-harness routing logic that selects execution backends at runtime. The context-retentive prompt engineering pipeline addresses a core meta-harness challenge: preserving state and semantic context across agent handoffs in multi-phase workflows. For researchers tracking harness design, SolidGPT illustrates how domain-specific tool integration (VSCode, Notion, vector DB) and human-in-the-loop approval can be embedded as first-class harness stages rather than post-hoc add-ons.