JarvisQwen — Autopilot Control Plane for Knowledge Work

A 24/7 autopilot for knowledge work on Qwen Cloud: watches sources, triages with qwen3.6-flash, deep-reads with qwen3.7-max — budget-capped, crash-safe, fully audited. ~$0.30/day, 30x cheaper.

Comment 1

Inspiration

Every knowledge worker I know runs the same loop by hand: watch sources → triage what matters → read the important few deeply → write up a briefing. It's mechanical, it's endless, and it's exactly what an agent should do while you sleep.

People have tried automating it — but by routing everything through a frontier model, they end up paying ~$10/day per workflow and still don't trust it to run unattended. I became convinced the hard problem was never intelligence. It was economics and trust: making autonomy cheap enough to leave on, and safe enough to walk away from.

What it does

JarvisQwen is a 24/7 autopilot for knowledge work on Qwen Cloud. Point it at a topic once and it runs on its own — polling sources on a schedule, triaging with a cheap model, deep-reading only what survives with a frontier model, remembering what it learned, and delivering a briefing every morning. Your laptop can be off; it lives in the cloud.

The flagship connector tracks research literature (arXiv), but the engine is workflow-agnostic — a news-watch connector already ships in this build, and JarvisQwen even routes "is this an academic or a news query?" through qwen3.6-flash, so the model decides how to fetch, not just what to summarize.

Crucially, it's production-ready and human-in-the-loop: destructive or outbound actions never fire automatically — they pause in an approvals queue and resume seamlessly from checkpoint once you click approve. A hard budget breaker means it can run unattended without ever surprising you with a bill.

The result: ~$0.30/day, about 30× cheaper than a frontier-only pipeline, with no loss in output quality.

How I built it

The whole system runs on the Qwen family via Qwen Cloud (DashScope) and is organized as four subsystems around a single idea: a cheap always-on control plane commanding expensive, on-demand experts.

1. Cost governance — the core innovation. Every LLM call in the system passes through exactly one function: redact → semantic cache → budget guard → tier router → resilient call → audit. Nothing can bypass it. The tier router sends work to the cheapest model that can do it — qwen3.6-flash ($0.25/$1.50 per Mtok) triages 50 papers for ~$0.03, and only the ~5 that pass escalate to qwen3.7-max ($2.50/$7.50) for deep summaries at ~$0.26. Cost is metered per-token against Qwen's official price table, not estimated.

2. Orchestration. Every pipeline step checkpoints its state and emits a verifiable artifact. Crash, restart, or network drop → the task resumes from the last checkpoint; paid tokens are never spent twice. A watchdog reclaims zombie tasks; per-provider circuit breakers with exponential backoff prevent retry storms from eating quota.

3. Memory. Every task writes episodic memory; a nightly off-peak job consolidates recurring facts into long-term semantic memory, with temporal arbitration and access/recency-based forgetting so retrieval doesn't degrade as the store grows.

4. Security. A three-layer egress gateway (regex → entropy → NER) replaces PII and credentials with placeholders before any text leaves for the cloud, restoring them after the reply; external documents are wrapped as "data, not instructions" to isolate prompt injection; every call lands in an append-only audit trail.

Stack: Alibaba Cloud · DashScope · Qwen (3.6-flash / 3.7-plus / 3.7-max) · FastAPI · SQLite · Python · LiteLLM · Next.js · React Flow · TypeScript · Tailwind · Docker.

Challenges I ran into

  • Exact cost metering for brand-new models LiteLLM didn't price yet — solved with a Qwen-official price table that takes priority over library estimates.
  • Checkpointing that never re-bills a completed, already-paid step after a crash mid-pipeline.
  • Redacting PII without wrecking summary quality — placeholders have to survive a round-trip through the model and restore cleanly.
  • A subtle full-app deadlock: on SQLite, holding a write lock across a 120s network call froze every write in the system. Fixed by committing to release the lock before every outbound call — now a documented, enforced invariant.

Accomplishments that I'm proud of

A complete production loop — budget breaker, checkpoint resume, circuit breakers, watchdog, audit, approvals, memory lifecycle — actually working together, not as slideware. Plus 14 unit tests, a full end-to-end smoke test, and a dry-run mode so judges can explore the entire system with no API key and zero cost.

What I learned

That model choice is an economics problem, not an intelligence problem. Once you treat the price gradient between tiers as a design tool — and make most "agent work" cheap deterministic code instead of token-billed reasoning — autonomy stops being a luxury you babysit and becomes something you can just leave running.

What's next

More connectors (news, GitHub, inbox) on the same engine; multi-user tenant isolation; a richer memory-inspection UI; and a one-click deploy so anyone can run their own private JarvisQwen.

Built With

Share this project:

Updates