AI Agents Collaboratively Build a Rust SQLite‑Like Engine – UBOS News

1. AI Collaboration: Claude, Codex & Gemini

The three agents were chosen for their complementary strengths:

• Claude – excels at high‑level design, documentation, and orchestrating the overall project structure.
• Codex – specializes in code generation, especially for low‑level systems programming in Rust.
• Gemini – provides rapid iteration, refactoring, and de‑duplication through a dedicated coalescer.

Each agent operated in its own isolated workspace, pulling the latest main branch, claiming a scoped task from a lock file, and pushing back changes after passing the cargo test suite. The coordination model mimics a distributed version‑control system, where tests act as the anti‑entropy mechanism that keeps the codebase consistent.

For a deeper dive into how AI agents can be orchestrated for software projects, explore our AI agents page.

2. Technical Architecture of the SQLite‑Like Engine

The engine follows a classic layered design, each layer implemented as an independent Rust crate to enforce strict module boundaries:

All crates share a common core library that defines data types, error handling, and utility functions. This modularity allowed Claude to focus on the design docs while Codex generated the low‑level storage code, and Gemini performed cross‑crate refactoring.

To see a real‑world example of a modular Rust project, check out the UBOS platform overview, which demonstrates similar crate separation for AI‑powered SaaS solutions.

3. Development Workflow & Key Results

The workflow was driven by a set of shell scripts that automate agent lifecycle management:

# launch_agents.sh – starts all agents in screen sessions
# agent_loop.sh   – each agent repeatedly:
#   1. Pull latest main
#   2. Claim a task from current_tasks/
#   3. Generate code + tests
#   4. Run cargo test
#   5. Commit & push if tests pass
# coalesce.sh     – runs Gemini to deduplicate and merge divergent changes

Key metrics from the two‑day sprint:

• ~19 k lines of Rust code (≈16 k non‑comment, non‑blank lines).
• 282 unit tests covering parser, planner, executor, and storage layers.
• 54.5 % of commits were coordination actions (lock, claim, release).
• All tests passed on every push, ensuring continuous correctness.

The oracle‑style validation—comparing query results against the reference SQLite binary—proved decisive. Each generated query was executed on both the new engine and SQLite; any discrepancy caused an immediate rollback.

For developers interested in rapid prototyping of AI‑driven workflows, the Workflow automation studio offers a visual canvas to orchestrate similar pipelines without writing shell scripts.

4. How to Replicate the Rust SQLite Project

Below is a concise, step‑by‑step guide for anyone who wants to run the same AI swarm on their own machine.

1. Clone the repository:

   git clone git@github.com:kiankyars/parallel-ralph.git
   cd parallel-ralph/sqlite

2. Make the scripts executable:

   chmod +x *.sh

3. Install required CLIs (Claude, Codex, Gemini) and ensure they are in $PATH. Also install screen, git, the Rust toolchain (rustup), and sqlite3 for validation.
4. Start the agents:

   ./launch_agents.sh

5. Monitor progress in the agent_logs/ directory. The PROGRESS.md file is updated after each successful commit.
6. If you need to restart agents (e.g., after a rate‑limit pause), run:

   ./restart_agents.sh

7. Run the coalescer periodically to merge duplicate work:

   ./coalesce.sh

Note that the coalescer was only executed once at the end of the original experiment, which highlighted the need for more frequent de‑duplication. Future runs should schedule coalesce.sh as a cron job.

For a quick start with pre‑built templates that accelerate AI‑driven development, explore the UBOS templates for quick start. Templates such as the AI Article Copywriter or the AI SEO Analyzer can be adapted to generate boilerplate code for database projects.

5. Current Limitations & Open Challenges

While the prototype is functional, several constraints remain:

• Documentation bloat: The PROGRESS.md file grew to 490 lines, making manual navigation cumbersome.
• Token‑usage visibility: Each LLM provider reports usage differently, preventing a unified cost analysis.
• Rate‑limit interruptions: Agents occasionally stalled when hitting API limits, leading to partially completed commits.
• Coalescer frequency: Running the de‑duplication step only once left a lot of redundant work in the repository.

Addressing these issues will require tighter observability (e.g., logging token consumption per request) and more aggressive scheduling of the coalescer.

Our UBOS partner program offers resources and consulting to help teams build robust AI‑augmented pipelines that overcome such limitations.

6. Future Work & Potential Impact on the Ecosystem

Looking ahead, the team plans to extend the engine in several directions:

1. Substantive run‑rate tracking: Capture per‑agent throughput to identify bottlenecks caused by rate limits.
2. Unified commit attribution: Ensure Claude, Codex, and Gemini all add identifiable signatures to each commit, simplifying audit trails.
3. Observability dashboard: Visualize test pass rates, token usage, and lock contention in real time.
4. Feature expansion: Add full‑text search, JSON support, and a pluggable storage backend (e.g., RocksDB).

Beyond the technical roadmap, this experiment demonstrates a paradigm shift: AI agents can act as autonomous developers, handling everything from design docs to production‑ready code. When combined with platforms like Enterprise AI platform by UBOS, organizations can scale development velocity while maintaining high quality.

For startups eager to experiment with AI‑first product development, see UBOS for startups. For SMBs looking for ready‑made solutions, the UBOS solutions for SMBs page outlines pre‑built integrations that accelerate time‑to‑market.