Skip to content

Argus — full command guide

Argus is a single-user Telegram research + media bot. It runs a multi-agent LangGraph engine for deep research (grounded in live Exa / web / arXiv / GitHub search, not the model's memory — every source is fetched and read into cited evidence notes, and every claim in the report is checked against those notes), downloads real media from YouTube / X / Reddit / Instagram into your vault, transcribes it, and keeps a resumable history of every run.

Send /help for the compact quick-reference; this file is what /help full delivers.

Research

/research <topic>

Runs the full deep-research loop with two human-in-the-loop (HITL) gates. A live progress card (stage, counts, last event) follows the run while it works.

  1. Plan gate — Argus drafts a research brief and runs a live discovery wave first (Exa/DDGS/arXiv/GitHub), then shows you the sub-questions plus the real sources it found (title + URL). The brief carries no URLs at all, so hallucinated links are structurally impossible — you approve actual evidence. Links you put in the question itself (a GitHub repo, a product page, docs) are read before the brief, so the plan is about that project; the card lists them under Read from your links (or says why one could not be read), and research always reads them. A repo or a site's front page also brings up to three of its most fitting parts — for a repo its docs, releases, changelog or homepage; for a site the docs, pricing or feature pages it links to — picked by your question's words. A deep link, or "only the README" / "just this page" in the question, reads that page alone. The card also names the report's archetype, the recency window, the engines profile and an Exa cost estimate (when Exa is on). Buttons:
  2. Length (TL;DR / Short / Medium / Long / Lecture) — the report's shape.
  3. Depth (Quick / Standard / Deep / Exhaustive, or Auto, which follows the length) — how much research: waves, fetches, gap waves and rewrites. Deeper presets read more sources and take longer.
  4. ⚙ profile — cycles the engines profiles (see /engines); a profile that cannot run is marked ⚠ and Approve refuses it with the reason.
  5. 🕒 recency — cycles auto (the brief decides) / past day / week / month / year / any (no recency filter).
  6. ✅ Approve — research the plan with these choices.
  7. ✏️ Edit — reply with changes; Argus redrafts the plan and re-searches.
  8. ❌ Cancel — drop the run.
  9. Report preview gate — after deep research (every source is read and digested into evidence notes), the outline, the section writers, the analyst and the review panel, you see the report head. It opens with a quality line (how many findings were judged and how many claims were cut), any warning banner, and the run's degradation notes. When the question asks for numbers (costs, revenue, growth, "with calculations"), the report ends with Worked numbers: each calculation's formula, its inputs — a figure with the source that states it, or a labelled assumption — and the result, computed by code rather than the model. Buttons:
  10. 📤 Send — deliver the .md + .pdf (and finish the run).
  11. 🔎 Extend — another research pass to deepen it (capped rounds).
  12. 🔁 Revise — reply with what to change; Argus rewrites the report from the same evidence with your notes (capped rounds).
  13. ❌ Cancel — drop the report.

Pre-pin the length without the keyboard: /research /length long <topic>.

Length modes

Mode Shape
tldr one short paragraph
short a compact answer (default)
medium a few pages with sections
long a longer sectioned report
lecture Part I–IV + References + Appendix

What the report guarantees - Cut, not flagged. The grounding judge checks every finding against the quotes of the notes it cites. A claim it rejects is removed from the body (whole sentences) and listed under "⚠ Flagged claims (removed from the body)"; one that cannot be located stays and is listed as such. - TL;DR from the report itself. The TL;DR is compiled from the kept, judged takeaways (or each section's first kept finding), never written by a model on its own. - Analysis. Every report but a TL;DR gets an "Analysis" section with takeaways labelled high / medium / low confidence (unless the run's config turns the analyst off). - Banners. "⚠ Not fact-checked" means some findings were not judged (the judge failed, or a section cites sources but had no finding to check); "⚠ Degraded run" means a per-item step (digests, finding extraction, section writers, judge batches) skipped a large share of its items. Both say why, and the preview repeats them. - Degradation notes list every declared fallback the run took (for example keyword triage instead of the reranker), by round. - evidence.json next to the report holds every source, note, quote check, finding and verdict (the console's tap-to-verify reads it).

/ask <question>

A quick, single-shot answer from the model's own knowledge. No search, no plan, no gates — use it for fast look-ups, not for claims you need cited.

The console (Mini App)

The Argus menu button next to the chat's text field opens the console: the runs list, a run's live progress, its plan gate (with the same knobs as the chat card), the report with tap-to-verify citations (tap [n] to see the source and its quotes) and Send to chat, a new-research form, and the engines settings. Appearance picks a light and a dark theme and whether to follow Telegram's light/dark or always use one. A session that is too old shows "Session expired — reopen from the menu button".

The console is optional: if it is down, research and media in chat keep working, and /status says why. With the default quick tunnel the console's address changes on every restart; the menu button is always kept current.

Media → vault

Downloads and transcripts are written into your DS vault:

…\Assets\Argus\media\<platform>\        (the .mp4 + .info.json)
…\Assets\Argus\transcripts\<platform>\  (.txt / .srt)

/find [yt|shorts|reddit] <query>

Search for videos, then act on each result with buttons: - ⬇ download to the vault - 📝 transcript (captions for YouTube, speech-to-text otherwise) - ⬇+📝 both

Default scope is YouTube; shorts biases to Shorts, reddit searches Reddit video posts. The result pool expires after a while; search again if a button stops working.

/fetch <url> [url…]

Download one or more media links straight into the vault — no search step. You can also just paste any supported link into the chat and Argus offers the same download / transcript menu. Supported: YouTube (incl. Shorts), X/Twitter status links, Reddit posts / v.redd.it, Instagram reels/posts.

Instagram (and some X) downloads need login cookies. Public content works out of the box; for the rest, set ARGUS_YTDLP_COOKIES (a cookies.txt) or ARGUS_YTDLP_COOKIES_BROWSER (e.g. firefox). A file over Telegram's bot upload cap (about 50 MB) comes as a private download link from your PC instead (it expires; see the media settings), with an Open button for the console.

Each saved item gets buttons: 🎵 MP3, 📝 Transcribe, 🏷 Tags and 📱 Open (its page in the console). The pasted-link menu has 🎵 too: the link's audio straight to mp3.

/quality [auto|min|max|<height>]

Global download quality. auto picks a sensible cap, max/min are the extremes, or give a pixel height like 720. With no argument it shows the current setting and whether ffmpeg is available (needed to merge high-res video+audio).

/transcript <indices> [format=txt|srt]

Fetch YouTube captions for videos picked from your last /find (or /video) results. Index syntax: 2, 2,4, 2 4, 1-3, all. format=srt keeps timestamps. Auto-caption line duplication (the "rolling window" repeat) is collapsed automatically.

/transcripts

Browse the latest transcripts saved in the vault, with 📤 buttons to re-send any of them. Each line shows its asset:<N> id for /append.

Sending files to the bot

Send a video, audio file, voice message, video note, or a transcript (.txt .md .srt .vtt) and Argus saves it to the library with the item buttons above. Telegram lets bots download files only up to 20 MB; for a bigger one Argus answers with an Upload in Argus button (the console's upload takes files up to ARGUS_MEDIA_UPLOAD_MAX_MB, 4096 by default).

/media and the console's Media section

/media shows what the library holds and opens the console's Media section, which has five tabs: - Library — every saved video, audio file and transcript, newest first: search titles, tags and gists; filter by type, group or tag. - Get — paste a link, Read link to see what it offers (the real resolutions, the source audio bitrate), then save it as video at a chosen quality or as mp3 (320 kbps is mp3's maximum; V0 is high-quality VBR). Or upload a file from the device (sent in pieces; keep the console open), optionally transcribing it or making an mp3. - Review — tag suggestions waiting for you (below). - Jobs — downloads, conversions, transcripts and tagging in progress. The list is lost on a bot restart; the files are not. - Settings — default video quality (shared with /quality), mp3 quality, transcript language and timestamps, auto-tagging, link lifetime.

/rename <asset:N> <new title>

Retitle a library item — or Rename on its console page. An item's parts (its mp3s and transcripts) take the new title too. Downloads and files sent to the chat are named after the title; the file in the vault keeps its name.

An item's page plays the file (seeking works), downloads it to the device, sends it to the chat, makes an mp3, transcribes it (language, timestamps), lists its parts (mp3s, transcripts) and can add a transcript to a research run — then Continue ingests it (as /append + /continue).

Tags and groups (you confirm them)

After each download, upload or transcript, Argus asks the cheap model tier (role media.tag) for a few tags, one group, a two-line gist and the links it saw; GitHub repos in the description or transcript are always picked up. A suggestion is only a suggestion: it waits in Review (and in the chat, with ✅ Accept) until you keep, drop or add tags and pick a group. Turn the automatic suggestion off in the media settings; Suggest tags on any item (or for up to 20 untagged items at once on the Review tab) asks again.

Links to files are signed, expire, and only work through the console's current address — the quick tunnel changes it on every restart, so make a new link after one.

Transcription engines

  • YouTube → caption extraction first (fast, no media download), then speech-to-text if the captions fail. The order is configurable.
  • X / Reddit / Instagram (no caption tracks) → speech-to-text over the downloaded clip.
  • The speech-to-text engine is local faster-whisper by default (CPU; the first run downloads its model), or an OpenAI-compatible audio API such as Groq's Whisper. /engines transcriber shows and switches it (below).
  • The transcript header names the engine that produced it.

Research history (resume & extend)

Every run is registered in a SQLite library and gets its own checkpoint thread, so runs survive bot restarts and can be picked back up. Buttons on messages sent before a restart keep working.

/runs

List this chat's runs (newest first) with their short ids and status glyphs. Use the ids with /continue and /append.

/status

Each tracked run's stage, elapsed time and last event (or the gate it waits at), your recent runs and their report folders, and the console link with its health.

/append <run-id> <url…|asset:N…>

Queue extra sources onto an existing run — web URLs, or vault transcripts by their asset:<N> id (see /transcripts). They are always ingested, outside every budget, on the next /continue or Extend; one that cannot be fetched is named to you with the reasons, and /appending it again queues it again.

/continue <run-id>

  • If the run waits at the plan or preview gate (even after a restart), it re-attaches and re-shows that gate.
  • If the run stopped mid-way (cancelled, interrupted by a restart, or failed), it resumes from its last saved step.
  • If the run paused (⏸) because every model engine ran out of quota, it reruns the step that paused once the quota resets — the run stops there rather than skipping item after item into an empty report. The pause message says exactly what /continue will do.
  • If the run finished: with appended sources queued it does an append-only pass (ingests exactly your sources, no new searches); otherwise it runs a fresh search pass to deepen the report. Either way it ends at a new preview.

Appended local files are cited as file:///… sources and pinned through ranking, so your own materials always make it into the report.

/cancel [run-id|all]

Stop a run. A run that is working finishes its current step, saves its checkpoint and stops (the card says "cancelling — finishing the current step"); /continue <id> resumes it later. Research stops between fetches and keeps what it already read. A run waiting at a gate is cancelled at once. With one run in flight the id is optional; with several, pass the id or all.

Only one run researches at a time (free-tier limits and the Exa budget): a second start or approve while one runs answers "busy" and names it. Runs waiting at a gate do not count.

/engines

Which model serves each step of the pipeline. Engines are grouped in profiles (the shipped ones are in argus_engines.json; the default uses the FreeLLMAPI proxy). Each role (brief drafting, digest, section writing, grounding judge, …) has a primary engine, optional fallbacks and a declared failure policy.

  • /engines — the active profile, every role's binding, validation problems, the last run's served models, the judge-diversity check and this month's Exa spend.
  • /engines use <profile> — switch profiles (refused, with the reason, if the profile cannot run: a missing API key, an unchosen model).
  • /engines tier <cheap|strong|judge> <provider>/<model> — change a tier; every role that follows the tier moves with it.
  • /engines set <role> <provider>/<model>, /engines fallback <role> <provider>/<model> — pin or extend one role.
  • /engines reset [profile] — drop your changes.
  • /engines models <provider> — the models a provider serves.
  • /engines transcriber [faster_whisper|openai_audio [provider/model]] — show or switch the speech-to-text engine.

Provider definitions (URLs, key names) are file-only. The console's Engines page does the same, one change at a time.

/delete

Free up disk space. Pick a category (Runs / Media / Transcripts), multi-select items (each shows its size), confirm the total, and Argus removes the files, the report folders, the checkpoint threads, and the registry rows. In-flight runs are refused, and only files strictly inside the Argus vault roots are ever touched.

Notes

  • Reports are written to the vault research-history folder with a human-readable run.md sidecar, metadata.json and evidence.json, and registered in the library.
  • The registry DB (argus_library.sqlite) and checkpoints (argus_checkpoints.sqlite) live in the project directory, not the synced vault, to avoid sync/lock corruption.
  • Launch the bot from the desktop Start Argus Bot shortcut (it calls Git Bash + scripts/run.sh).