Your AI team catches what you miss, stores what matters, and gets sharper with every session — automatically, every night, without you lifting a finger.
The five-stage vigilance cycle
Expand any step. Each one has a plain-English explanation for context, and a technical breakdown for the engineers in the room.
Think of this as your AI team running their morning sweep. They check every open deal in your CRM, scan your recent emails, look at your task backlog and calendar, and cross-reference your accumulated business knowledge. Then they produce a structured briefing: what opportunities are stalling, which client went quiet, what follow-up nobody has done, what risks are emerging. You didn't have to ask — they just did it.
skill_runners/opportunity_radar.py aggregates a tenant-scoped context snapshot from: CRM leads/contacts, IMAP email snippets (subject + sender, never full bodies), active tasks, calendar events, and existing kb_nodes from Memoria. The snapshot is sent to the LLM via model_policy_service.resolve_model() (openrouter-mini for Pro+, Groq for free/trial). Output is a structured JSON envelope with five sections: top_opportunities, stale_opportunities, next_followups, content_gaps, risks_and_blockers. The runner is fully read-only. Triggered manually from the Skills panel, or automatically via a tenant-configured APScheduler cron (e.g. 0 8 * * 1-5).
The results appear as a briefing in your AEGIS dashboard under the Opportunity Radar view. Each catch has a title, a summary of what was found, and a suggested next action. This is an information layer — AEGIS is showing you a picture, not making decisions. Nothing has changed in your CRM, your inbox, or anywhere else. You're in control from here.
The structured envelope is persisted as a skill_runs row. The Opportunity Radar UI reads the latest run (or a pinned demo run) via radar_demo_pin_service.get_latest_radar_payload(). Items classified as setup gaps — disconnected integrations, empty data sources — are filtered using deterministic _SETUP_GAP_MARKERS before display. These are infrastructure observations, not business signals, and are never surfaced as actionable catches.
For each catch, you decide whether it belongs in your business's permanent knowledge. Click Accept and it goes into Memoria. Scroll past it and it doesn't. This gate is non-negotiable: AEGIS will never decide on its own what is strategically important about your business. That judgment stays with you. Not because we couldn't automate it — because institutional knowledge without human oversight isn't institutional knowledge, it's hallucination at scale.
Clicking Accept calls POST /skills/opportunity-radar/accept → accept_radar_item() in skill_routes.py. This is the contractual governance boundary defined in the AEGIS Founding Contract §III. Items are blocked from acceptance if they are: setup gaps (matched by _SETUP_GAP_MARKERS), missing required evidence fields, or lacking a valid section classification. Only items that pass all validation checks proceed to Memoria writeback.
What you approved doesn't disappear when you close the dashboard. It becomes part of your business's living knowledge graph — Memoria. Every agent on your team can read from this graph. So the next time your Sales agent is briefing you on a client, or your Finance agent is reviewing a deal risk, the context you built over months is already in the room. The longer you use AEGIS, the more your team knows — without you repeating yourself.
Accepted items are written to kb_nodes in your tenant's PostgreSQL schema as node types: agent_insight, accepted_strategy, or partner_strategy, with trust_level=human_approved (highest tier). Nightly at 02:00 AM, job_nightly_memoria runs two operations: (1) confidence decay — nodes that aren't referenced or reinforced gradually lose confidence, preventing stale context from corrupting future runs; (2) crystallization — nodes with consistently high confidence across multiple references are promoted to crystallized tier, becoming permanent institutional knowledge. All 8 agents query the graph via pgvector semantic search during task execution.
Every time you rate a skill output with 👍 or 👎, you're teaching the system. AEGIS tracks which of its procedures are working and which aren't. Overnight, it identifies the underperformers, rewrites their instructions based on your corrections, and notifies you via Telegram: "Market Intelligence skill auto-improved — was rated 3.1/5, new version now active." No configuration, no prompt engineering on your part — the system does it while you sleep.
Every skill run writes a skill_runs row with a rating field (from user thumbs up/down). Nightly at 03:00 AM, job_auto_learn queries skill_runs per tenant. Evolution threshold: avg rating < −0.3 AND ≥5 rated runs (configurable via auto_learn_threshold_rating / auto_learn_threshold_runs in tenant settings). The LLM generates an improved prompt version using recent feedback as context. Saved to prompt_history, immediately applied. Admin notified via Telegram. Requires auto_learn_mode=true in tenant settings; available on Pro+ tiers.
AEGIS runs two categories of background jobs. One you configure; one runs automatically for all tenants.
System jobs — always running
| Job | Runs at | What it does |
|---|---|---|
| job_syncer | Every 60 s | Picks up new tenant schedules from the database and registers them with APScheduler |
| job_nightly_memoria | 02:00 AM | Confidence decay on all kb_nodes + crystallization tier promotion |
| job_auto_learn | 03:00 AM | Scans skill_runs feedback, generates improved prompts for underperformers |
| job_nightly_pulse | 02:00 AM | Business Pulse CRM refresh — pipeline health metrics recalculated |
Tenant schedules — you configure in Workflows
Set a cron expression (e.g. 0 8 * * 1-5 = weekdays 8am), choose a task prompt and an agent. Within 60 seconds, the job_syncer registers it. When it fires: APScheduler → execute_task() → openclaw → LiteLLM → agent response → result stored → Telegram notification (if enabled). If the LLM is temporarily unavailable (quota, timeout), a neutral delay notice is stored and the error is never surfaced to your Telegram. The schedule runs again automatically at its next interval.
| Raw AI (one-shot) | AEGIS Loop |
|---|---|
| Forgets everything after the session | Memoria graph grows with every approved catch |
| You bring all context manually | CRM, email, tasks auto-injected before every LLM call |
| Same outputs every time | Skills improve from your feedback — every run is logged |
| You have to remember to ask | Radar surfaces what you didn't ask about |
| No audit trail | Every run, approval, prompt version, and decision logged |
| Platform owns your data | Schema-per-tenant — your data never touches another account |
auto_learn_mode setting enabled, available from Pro (€49/mo) upward. Paid tiers use reliable model capacity (OpenRouter GPT-4o mini); free/trial runs use Groq Llama.8 agents. Persistent memory. Skills that improve every run. Free to start.