Datasets:

ambient-intelligence-labs
/

egoproactive-synth-annotations

A practical guide for agents that need to turn egocentric task videos into structured, proactive assistant walkthroughs (timestamped decision + utterance events). Written from a working setup; every gotcha below was hit and fixed in practice.

1. What it produces

The ambient agent (ambient/agent.py::run_agent) is a tool-calling video agent. Given a video and the annotation prompt, it inspects the video across several turns with vision tools, then emits a rich JSON walkthrough:

task_name / goal / (procedure)
walkthrough: [ {timestamp, decision, interaction_type, visible_context, utterance,
                timing_rationale, confidence, linked_user_response, ...}, ... ]
silent_intervals: [ {start_time, end_time, reason}, ... ]
failure_modes: [...]

decision ∈ intervene | correct | confirm | redirect | insist | observe | complete. Timestamps are real seconds (not fixed chunks). This is dramatically richer than a single-pass VLM labeling (e.g. on 4 egoconv clips: single-pass gave 0–7 cues/clip; the agent gave 8–15 decision-typed events + silent intervals, and it infers the task from the video — e.g. a "HomeDIY"-labeled clip → "Bedroom Organization and Desk Tidying").

The reference prompt is annotation_prompt.txt (5-stage: retrospective understanding → action timeline → intervention opportunities → walkthrough → validation, with a strict causal constraint: each utterance justified only by evidence up to its timestamp).

2. Two models, two endpoints

role	config field	example	what it does
orchestrator	`agent_model` @ `agent_base_url`/`agent_api_key`	`deepseek/deepseek-v4-flash` (OpenRouter)	drives the tool-calling loop, writes the walkthrough
vision	`llm_model` @ `llm_base_url`/`llm_api_key`	`nvidia/Qwen3.6-27B-NVFP4` (local vLLM) or `qwen/qwen3.6-27b` (OpenRouter)	analyzes clips for `focus_clip`/`search_clip`

The orchestrator only needs text (tool results are text descriptions), so keep it on a cheap capable model. The vision model is the cost/quality driver — self-host it to cut cost ~10×.

Endpoint split: by default run_agent sent both calls to llm_base_url. It's patched (agent.py, ~line 357) so the agent uses agent_base_url when set, vision keeps llm_base_url. This lets you run vision on a local GPU and the orchestrator on OpenRouter simultaneously.

3. Deployment: local-GPU vision (recommended — cheap + fast)

Serve the vision model with the vLLM Docker image (no host installs; the container survives ssh-close, which sidesteps the VM process-persistence trap below). On a Blackwell GPU, use the NVFP4 build (native FP4, ~14 GB, fast):

docker run -d --name qwenvis --gpus all --ipc=host -p 8000:8000 \
  -v ~/hf_cache:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model nvidia/Qwen3.6-27B-NVFP4 --served-model-name nvidia/Qwen3.6-27B-NVFP4 \
  --trust-remote-code --gpu-memory-utilization 0.85 --max-model-len 32768 \
  --limit-mm-per-prompt '{"image":32}'      # vision tools send ~28 frames/call — set this high

Wait for readiness: curl http://localhost:8000/v1/models → 200. For a public endpoint, the host binds 0.0.0.0:8000; reach it at http://<host-ip>:8000 (open the port if firewalled). Then point the agent box's .env at it.

`.env` (on the box running the agent)

LLM_BASE_URL=http://<gpu-host>:8000/v1        # vision (local vLLM)
LLM_MODEL=nvidia/Qwen3.6-27B-NVFP4
LLM_API_KEY=EMPTY
AGENT_BASE_URL=https://openrouter.ai/api/v1   # orchestrator
AGENT_API_KEY=sk-or-...
AGENT_MODEL=deepseek/deepseek-v4-flash
SANDBOX_BACKEND=inprocess                     # local ffmpeg (needs ffmpeg on PATH)
INLINE_CLIPS=true                             # no S3: clips embedded inline
VIDEO_FOLDER=/abs/path/to/videos              # run_agent globs VIDEO_FOLDER/<video_id>*

OpenRouter-only alternative (no GPU, simpler, ~10× the cost): set both LLM_* and AGENT_* to OpenRouter, LLM_MODEL=qwen/qwen3.6-27b. See cost table in §7.

Deps for the agent process (not the vLLM container)

aiohttp tenacity pydantic pydantic-settings boto3 rich python-dotenv + ffmpeg on PATH. (boto3 is imported transitively even with INLINE_CLIPS=true.)

4. Driving it (the calling pattern)

run_agent(video_id, question, max_turns, output_structure) runs the loop. Give it a Pydantic output_structure (its JSON schema is appended to the prompt) and read the answer from the trajectory file (see gotcha #2).

from ambient.agent import run_agent
from pydantic import BaseModel, Field

class Walk(BaseModel):
    walkthrough: list[dict]; silent_intervals: list[dict] = []
    task_name: str = ""; goal: str = ""

q = open("annotation_prompt.txt").read() + f"""
# This input
Video id: {stem}. High-level task: a {task} activity. ~{dur:.0f}s.
TOOL BUDGET: inspect with AT MOST 5 focus_clip/search_clip calls (beginning / key middle / end).
Then STOP calling tools and output ONLY the final JSON walkthrough — no prose. Timestamps in 0..{dur:.0f}s.
"""
msgs = await run_agent(video_id=stem, question=q, max_turns=12, output_structure=Walk)
ann  = answer_from_trajectory(stem)   # read the final JSON from ambient/trajectories/*<stem>*.json

Run clips concurrently with asyncio.gather — they're independent (separate video_id, trajectory, frame cache), and the bottleneck is model latency, so it's ~N× faster.

5. Gotchas (each cost real time — do these)

Image-only vision models reject video_url. construct_payload sends clips as a base64 video_url; only gemini-class models accept that. For qwen (image-only) it fails with ClientConnectionError. Fix (already patched in ambient/llm.py): when the model isn't gemini, sample frames from the clip mp4 and send image_url blocks instead. Keep --limit-mm-per-prompt image budget ≥ the frames/call (~28).
The final answer is NOT in run_agent's return. On end_turn the loop breaks without appending the final assistant message to messages. Read it from the trajectory file (ambient/trajectories/trajectory_<video_id>_*.json, last turn's text); strip ```json fences, take the largest balanced {...} containing walkthrough.
Bound the tool budget or it never answers. Without "use ≤5 tools then output JSON", the agent spends all max_turns inspecting and emits no final JSON (looks like a parse failure). Put the budget in the question; max_turns=12 is comfortable.
Don't trust clip metadata durations — ffprobe. egoconv duration_in_sec is unreliable (says 64–92 s; real videos are ~300 s). Probe the actual file. And when globbing for the file, match the video extension — glob("<stem>*")[0] can hit the <stem>/ frames dir the tools create and crash ffprobe.
Process persistence on the VMs. Detached processes (nohup/setsid/tmux) get killed on ssh-close even with loginctl enable-linger (they stay in the session cgroup scope). Two robust options: run the workload in a Docker container (survives), or hold the ssh open from your side as a background task. systemd-run --scope/--user is the "proper" fix but was flaky here.
pgrep -f <name> matches your own command (the pattern is in your cmdline). Don't use it to decide "is it running" — check a log marker or a PID.
Vision reasoning verbosity. qwen3.6-27b is a reasoning model; give tool/vision calls enough max_tokens (≥2k) and strip <think>…</think> before JSON parsing. Don't disable thinking unless asked — longer max_tokens is the fix.

6. Output → training labels

To convert a walkthrough into per-8s-chunk $interrupt$/$silent$ proactive labels: bin walkthrough events by int(timestamp // 8) → that chunk is $interrupt$<utterance>; all others $silent$ . silent_intervals are a cross-check. decision types map naturally (intervene/correct/redirect/insist → interrupt; observe/confirm are optional). Frames for training come from the same videos.

7. Cost & scale (measured)

Per clip: ~7.5 vision calls (≈28 frames each) + ~4 orchestrator turns.

vision backend	$/clip	235 clips	notes
OpenRouter `qwen3.6-27b`	~$0.12–0.15	~$30–35	reasoning output @ $3.60/M dominates
local NVFP4 (Docker)	~$0.015	~$3.5	only deepseek on OpenRouter; ~10× cheaper + no rate limits

Wall-clock ~~5 min/clip; concurrent (~~10) ≈ ~2 clips/min → ~2–3 h for 235 clips. Videos must be on the agent box (VIDEO_FOLDER); ~8 GB for 235 egoconv clips.

8. Quick start (local-GPU path)

# 1. vision server (GPU box, Docker) — see §3, wait for /v1/models = 200, open the port
# 2. agent box: put ambient_agent/ + videos there; write .env (§3); install deps (§3)
# 3. drive it (§4) with annotation_prompt.txt, concurrent via asyncio.gather
# 4. read ann from ambient/trajectories/*  (gotcha #2)

Reference working driver: annotate_egoconv.py (probe+ffprobe, trajectory extraction, tool budget, concurrent gather). Reference prompt: annotation_prompt.txt.

Using the Ambient Agent for proactive video annotation