Edge-ML Research Copilot

A human-in-the-loop research agent for edge / TinyML papers (models that run on MCUs: STM32, ESP32, Arduino Nano 33 BLE, etc.). It does the labor of research — survey, gap-finding, code, on-hardware benchmarking, drafting, citation validation, plagiarism check — and you own the novelty, the claims, and the final writing.

It is not a "press start, get a publishable paper" machine. See Honest scope.

Honest scope (read this first)

| Stage | Who does it | Automatable? | |---|---|---| | Survey recent papers, build gap table | Agent | ✅ Yes | | Propose hypothesis / experiment plan | Agent drafts | ⚠️ You approve — agents can't reliably judge novelty | | Write training / quantization / benchmark code | Agent | ✅ Mostly | | Run on real MCU (latency / power / memory) | Agent orchestrates, your lab hardware produces numbers | ✅ Yes (needs hardware) | | Analyze results, make plots/tables, capture seeds+env | Agent | ✅ Yes | | Draft paper sections from logged results only | Agent | ✅ Yes | | Validate every citation (Crossref) — no hallucinated refs | Agent | ✅ Yes | | Plagiarism / similarity check | Agent | ✅ Yes | | Novelty, contributions framing, heavy intro/conclusion edit | You + lab | ❌ Not automatable | | Final approval & submission | You | ❌ Human gate |

Target = high-impact venue (IF ~10). Realistic only over months with genuine novelty + real hardware + strong baselines + expert human writing. The agent gets you ~50–60% of the grind. The remaining ~40% (the part that earns the impact factor) is your research judgment and cannot be automated.

What this project deliberately does NOT do

• No "AI removal" / detector-evasion / humanizer. Disguising AI-generated text to evade detection violates the policy of essentially every IF-10 venue (IEEE, Springer, Nature, ACL) and can get a paper retracted + the author banned. Instead we disclose AI assistance (required by these venues anyway) and rely on your substantive human edit. The legitimate version of "make it read like a human wrote it" is the human edit pass — you co-author, you don't hide.
• No fabricated results. The writer agent may only cite numbers that exist in the experiment logs. If a number isn't logged, it cannot appear in the paper.

Architecture

                         ┌─────────────────────────────┐
   Next.js dashboard ◀──▶│  FastAPI server (server/)    │
   (frontend/)   SSE/REST│  - job state + approval gates│
                         └──────────────┬──────────────┘
                                        │
                         ┌──────────────▼──────────────┐
                         │  Pipeline (pipeline.py)      │
                         │  stages run, PAUSE at gates  │
                         └──────────────┬──────────────┘
                                        │
                ┌───────────────────────┼───────────────────────┐
                ▼                       ▼                       ▼
         CrewAI agents            Tools (tools/)          Lab hardware
         (config/*.yaml)   arxiv · crossref · dataset ·   MCU over USB
                            mcu_benchmark · plagiarism     (your lab)

Pipeline stages (each GATE pauses for your approval in the dashboard):

1. survey — pull + summarize recent edge/TinyML papers, build a gap table
2. GATE: direction — you pick the direction
3. proposal — hypothesis + experiment plan
4. GATE: proposal — you approve/edit (kills the novelty problem — you judge it)
5. engineer — write training/quant/benchmark code, run tests
6. experiment — run on MCU, collect metrics, capture seeds + env
7. GATE: results — you review the numbers
8. write — draft LaTeX sections from logged results, validate citations
9. qa — grammar/clarity/consistency + plagiarism check + AI-disclosure stmt
10. GATE: final — you do the heavy human edit and approve

Setup

Python 3.14 (your system default) is too new for CrewAI + the ML stack. Use a pinned 3.12 venv — your system Python is untouched.

# 1. backend
cd backend
./scripts/setup.sh          # installs uv if missing, creates .venv on Python 3.12, installs deps
cp .env.example .env        # add your OPENAI/ANTHROPIC key
source .venv/bin/activate
python -m research_agent.main --help

# 2. server (orchestration API for the dashboard)
uvicorn server.app:app --reload --port 8001   # oMLX owns :8000

# 3. frontend (in another terminal)
cd ../frontend
npm install
npm run dev                 # http://localhost:3000

Status of this scaffold

This is a runnable skeleton, not a finished product. Real implementations are marked # TODO(real) in code. The MCU benchmark tool ships as a documented stub you wire to your board's toolchain.

Verified working (tested against local oMLX Qwen-27B)

• ✅ oMLX connection (OpenAI-compatible, key from oMLX → Security tab)
• ✅ CrewAI → litellm → oMLX (raw call + full agent+task)
• ✅ Multi-source survey: OpenAlex + Semantic Scholar, impact-ranked, disk-cached (2.6s cold / instant cached — no arXiv rate-limit problem)
• ✅ Code-execution loop: engineer agent really writes files + runs them on this Mac
• ✅ Job state + human approval gates

⚠️ CRITICAL: native tool-calling is required, do not remove

oMLX supports OpenAI-style tool_calls, but litellm doesn't recognise the custom model name, so CrewAI defaults to text-based ReAct — which this reasoning model FAKES (it narrates Observation: lines in its chain-of-thought; files never get written, but it reports a plausible result anyway). LocalLLM.supports_function_calling() in llm.py forces native tool-calling ON to prevent this. If the engineer agent ever stops actually writing files, this override is why — check it first. Verify with: file appears in runs/workspace/ after an engineer run.

✅ Hardware-free MCU benchmarking (Zephyr + Renode, working)

No physical board needed. We simulate the nRF52840 (the Arduino Nano 33 BLE Sense MCU) running a Zephyr binary in the Renode simulator. mcu_benchmark builds the app and returns EXACT flash/RAM footprint (from the linker) + cycle-approximate latency.

• Setup: arm-none-eabi-gcc + west + Renode (~/.local/bin/renode) + Zephyr at ~/zephyrproject (toolchain = brew gnuarmemb, no separate Zephyr SDK).
• Driver: sim/run_bench.sh — bash sim/run_bench.sh <zephyr_app_dir> out.json
• Example app: sim/apps/hello_bench (build→Renode→parse verified).
• Gotchas baked into the driver: pass Renode absolute @paths; use emulation RunFor alone (not with start); time with k_cycle_get_32() (Renode models the RTC, NOT the Cortex-M DWT cycle counter).
• Sim→real: the same binary runs on a ~$35 Nano 33 BLE Sense for final IF~10 latency. (The user's Arduino Uno R3 / ATmega328 is too small for TinyML — sim is the path.)

Measured results (simulated nRF52840, Renode)

Produced by sim/run_bench.sh; raw JSON sits next to each app.

| App | Workload | Flash | Static RAM | Latency | |---|---|---:|---:|---:| | hello_bench | synthetic integer loop — smoke test, not inference | 21,308 B | 4,501 B | 2.99 ms | | tflm_bench | TFLite Micro hello_world sine regression, Invoke() | 58,820 B | 7,856 B | 0.083 ms |

Read these carefully:

• Footprint is exact — taken from the linker (arm-none-eabi-size), not estimated.
• Latency is cycle-approximate — Renode emulates the RTC, so treat it as an order-of-magnitude figure and re-measure on real silicon before making any published claim.
• hello_bench does not run a model. It times a dummy loop to prove the build → simulate → parse pipeline works end to end. It is not a TinyML result.
• hello_bench.workload_cycles is currently null: an earlier run parsed 98 cycles, which cannot be right for a 50k-iteration loop that took 2.99 ms at 64 MHz (~191k cycles). The UART parse was wrong; the field was cleared rather than left misleading.

Still stubs (the genuinely hard 40%)

• ~~TFLite-Micro inference app~~ — done, see sim/apps/tflm_bench and the results table above. Next: a quantized model of our own rather than the upstream sample.
• experiment stage orchestration (wire the engineer's run to a results.json hand-off)
• LaTeX/IEEE template + compile check in the write stage
• Real similarity/plagiarism tool in qa

Provenance and attribution

• backend/sim/apps/tflm_bench/ is the Zephyr TensorFlow Lite Micro hello_world sample, vendored to have a known-good real-inference workload to benchmark against. Copyright 2020 The TensorFlow Authors, Apache-2.0 — original headers are intact. The trained sine model and train/train_hello_world_model.ipynb are upstream, not mine.
• backend/sim/apps/hello_bench/, backend/sim/run_bench.sh, backend/sim/renode/bench_nrf52840.resc, and everything under backend/src/, backend/server/ and frontend/ are mine.
• The benchmark harness — build, simulate, extract footprint from the linker, parse app-reported timings — is the original contribution here, not the sample it runs.

Licence

Apache-2.0 (see LICENSE and NOTICE) — chosen for compatibility with the vendored Apache-2.0 TensorFlow sample.