DeepEye
A steerable self-driving data agent system that turns heterogeneous data sources into data videos, interactive dashboards, and analytical reports in a single run.
- Source repo
- HKUSTDial/DeepEye
- Stars
- ★ 270
- Last updated
- 3mo ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 65/100 · Some gaps
At a glance
- Works with
- Universal · cross-platform
- You'll need
- Typical use
- A business analyst who needs to jointly analyze a sales database, Excel reports, and PDF documents and deliver both a dashboard and a narrated data video to management.
- Main limitation
- Deployment cost is high: the full Docker service stack (Postgres, Redis, MinIO, Celery, nginx, etc.) must run, making lightweight usage impractical.
- Website
- deepeye.hk ↗ set on GitHub
- Maintenance
- Commits in the last 6 monthslast commit 2026-08-09
- Source review
- 65/100 · Some gaps
What does this agent do, and when should you use it?
DeepEye is an open-source, production-ready steerable self-driving data agent system from HKUSTDial, published as a SIGMOD Demo 2026 paper. Unlike linear ChatBI tools, it uses a workflow-centric architecture that handles heterogeneous data sources and complex iterative analysis without context explosion. It autonomously orchestrates multi-step workflows to produce three classes of artifacts: narrated data videos, interactive live-updating dashboards, and structured analyst-grade reports. Every draft passes through a Workflow Engine with four stages — Compiler (typed DAG parsing), Validator, Optimizer (topology-aware parallel scheduling), and Executor (isolated sandboxed code per node). The stack ships as a Docker Compose deployment with a FastAPI backend, Celery workers, a React + TypeScript frontend, and Postgres, Redis, and MinIO services. Human-in-the-loop controls let users inspect each step, including node-level SQL, in a live workflow inspector before and during execution.
Users connect data sources in the Data Sources panel — structured (PostgreSQL/MySQL, CSV, Excel), semi-structured (JSON, XML), or unstructured (PDF, TXT, Markdown indexed as Knowledge Bases) — then describe a goal in chat with @-references, e.g. "@Financial Metrics @Meta-data @Sales Database: analyze 2025 global sales performance, generate a video, dashboard, and analytical report." The system calls the configured LLM (LLM_API_KEY/LLM_BASE_URL/LLM_MODEL) to generate a workflow plan, which the Compiler parses into a typed DAG and renders in the Workflow Graph panel; after user confirmation, the Executor runs the DAG with isolated sandboxed code environments per node. Outputs are versioned per session and can be previewed inline, exported, or shared. Deployment runs docker compose up --build, which starts Postgres, Redis, MinIO, the backend API, Celery worker, runtime-control service, frontend, and nginx gateway; migrations run automatically and the app is served at http://localhost:8080.
- A business analyst who needs to jointly analyze a sales database, Excel reports, and PDF documents and deliver both a dashboard and a narrated data video to management.
- A data team that wants to review each agent-generated SQL query and workflow DAG via human-in-the-loop inspection before execution instead of black-box automation.
- A researcher with heterogeneous sources (JSON, XML, Markdown notes) who wants an orchestrated end-to-end analysis producing a shareable report.
- A consultant who needs versioned artifacts per analysis session that can be exported and shared.
- A team seeking a self-hosted, steerable analytics platform as an alternative to linear ChatBI tools.
Key setup facts
Pulled from the install and usage notes below. The project README has the current values.
- Install / run
docker compose up --build
- Environment variables
LLM_API_KEYLLM_BASE_URLLLM_MODELJWT_SECRET_KEYPOSTGRES_PASSWORDMINIO_ACCESS_KEY- Config files
.env- Install notes cover
- Docker
How do you install or deploy this agent?
Prerequisites: Docker and Docker Compose, a supported LLM provider key and model, uv for Python development and tests, Node.js/npm only if running the frontend outside Docker.
- Configure the environment:
cp env.example .envOpen .env and set at minimum:
LLM_API_KEY=...
LLM_BASE_URL=...
LLM_MODEL=...
JWT_SECRET_KEY=...
POSTGRES_PASSWORD=...
MINIO_ACCESS_KEY=...
MINIO_SECRET_KEY=...On shared machines, also set a unique COMPOSE_PROJECT_NAME and HOST_GATEWAY_PORT to avoid port conflicts.
- Start the stack:
docker compose up --buildThis starts Postgres, Redis, MinIO, the backend API, Celery worker, runtime-control service, frontend, and nginx gateway; database migrations run automatically. For development, run the quality gate with make check or make check-install.
How do you use this agent?
- Open http://localhost:8080 (if unavailable, verify
.envport settings such asHOST_GATEWAY_PORTand check all Docker services withdocker compose ps).
- In the Data Sources panel, add sources: structured (PostgreSQL/MySQL, CSV, Excel), semi-structured (JSON, XML), unstructured (PDF, TXT, Markdown indexed as Knowledge Bases).
- Describe your goal in chat with @-references, for example:
@Financial Metrics @Meta-data @Sales Database
Analyze the 2025 global sales performance,
generate a video, dashboard, and analytical report.- DeepEye creates a workflow plan and asks for confirmation before running; the Workflow Graph panel renders the DAG, and each node shows its inputs, exact SQL queries executed, status, and outputs.
- Review outputs (data videos, dashboards, reports) inline in the right panel; artifacts are versioned per session and can be exported or shared.
Stop the stack:
docker compose downAdd -v to also remove stored volumes/data.
What are this agent's strengths and limitations?
- Workflow-centric architecture decomposes complex intents into isolated AgentNodes and deterministic ToolNodes, explicitly targeting hallucination elimination — a clear differentiator from linear ChatBI tools.
- Database-inspired Workflow Engine (Compiler, Validator, Optimizer, Executor) guarantees structural correctness and accelerates runtime through topology-aware scheduling.
- Human-in-the-loop: a live workflow inspector and runtime steering controls with node-level SQL visibility make automation transparent and interruptible.
- Unified multimodal orchestration integrates databases, documents, CSV/Excel, and APIs in one workflow, producing videos, dashboards, and reports in a single run.
- Backed by an accepted SIGMOD Demo 2026 paper and CI (pytest), giving auditable academic and engineering grounding.
- Deployment cost is high: the full Docker service stack (Postgres, Redis, MinIO, Celery, nginx, etc.) must run, making lightweight usage impractical.
- Requires a supported LLM provider key and model (LLM_API_KEY/LLM_BASE_URL/LLM_MODEL), incurring per-use provider costs.
- Docs explicitly warn to treat the current stack as a local development environment; exposing it beyond a trusted local environment requires replacing secrets and reviewing auth, CORS, Docker socket access, and code-execution boundaries.
- LLM-orchestrated workflows with Docker-backed code execution introduce failure surfaces; you must set resource limits and cleanup policies yourself.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| DeepEye This agent | 65 · Some gaps | — | ★ 270 | 3mo ago | Python | — |
| OpenAgents | 42 · Major gaps | Web appFree + model costs | ★ 4.9k | 2y ago | Python | OpenAI API |
| DecisionBox | 52 · Major gaps | Self-hosted serviceFree + model costs | ★ 123 | 1d ago | Go | OpenAI API · Claude API |
| AutoResearchClaw | 58 · Major gaps | CLIFree + model costs | ★ 15k | 3mo ago | Python | Codex · Claude Code · OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
Docs candidly disclose high-risk areas (Docker socket, generated-code execution, example secrets) with a hardening checklist; but runtime-control mounts docker.sock (host-level privilege) and core/sandbox/main.py executes LLM-generated code via bare exec() with no resource or network limits — least privilege is thin. Workflow plan confirmation before run (HITL) and per-node SQL/input inspection give adequate transparency; secret handling has guidance but no implementation evidence in the packet. pip-audit, npm audit and CodeQL are thorough. Rollback is only destructive `docker compose down -v`, with no upgrade path.
Regression tests (supervisor routing, schema caching, Docker sandbox integration markers), multi-job CI, compose config validation and smoke tests support self-consistency; a global exception handler returns structured 500/422 responses, though messages are terse. Warmup handles external dependency availability with a STRICT toggle. Deduction: no release/version support policy evidenced.
Quickstart, running example, scenario samples (retail ops) and Docker-first environment assumptions cover the intended data-analysis audience well. Trigger precision is thin: @mention/goal parsing mechanisms are not shown in the sample; LLM-generated plans are validated but false-trigger risk is unquantified. Deduction: trigger boundaries are declarative only.
Clear monorepo layout, docs with RFCs, security model and remediation checklist, stepwise install notes with troubleshooting, full Apache-2.0 LICENSE, and candid known-limitations — all adequate. But versioning stops at 0.1.0, there is no CHANGELOG, and SECURITY.md admits tagged releases are not established; maintenance responsibility rests on an unverified publisher's GitHub issue process. Deduction: no changelog/versioning.
Three artifact classes plus a workflow DAG with runtime steering offer real differentiated marginal value; artifact versioning/export improves output usability. However the README's 'production-ready' claim contradicts the security model's 'active development preview' self-description, and the multi-container + LLM stack's cost is unquantified. Deduction: claim contradiction and unquantified cost.
README cites arXiv paper, SIGMOD DOI, BibTeX and CI badges, giving traceable anchors; tests corroborate some capabilities (caching, orchestration). But 'production-ready' and 'eliminate hallucinations' assertions clash with the security docs, and fact vs. inference is not cleanly separated. Deduction: marketing claims lack in-repo support.
- Do not deploy the default stack beyond a trusted local environment: runtime-control mounts docker.sock, equivalent to host control.
- The exec()-based sandbox in core/sandbox/main.py has no resource/network/timeout limits and is not a security sandbox.
- README's 'production-ready' contradicts the security model's 'active development preview'; weigh the security doc as authoritative.
- Replace all example secrets and set a strong DOCKER_CONTROL_API_KEY before first run.
- No CHANGELOG or release policy; upgrade and rollback paths are unclear.
FAQ
Is DeepEye open source?
Is DeepEye safe to use?
Is DeepEye still maintained?
Who makes DeepEye?
What is DeepEye's official website?
Thanks — we use this to improve the page.