Five layers. Eighteen core services. Seven stewardship domains. One contract: nothing acts without a gate, and nothing happens without a trace.
Workflow engine coordinating triggers, schedules, and event-driven automation — the conductor that turns intent into executed work.
A supervised agent sandbox — Python 3.12 and Node 20 polyglot execution under process supervision, isolated and recoverable.
Athena authorization gatekeeping and Aegis endpoint scanning. Every privileged action requires a signed decision. Shell execution is blocked by default.
A hybrid memory stack — vector, cache, and relational stores layered into episodic, semantic, graph, and lesson-based memory with consolidation.
The reasoning and reflection layer — clustered models in collaborative decision tiers, governed by the Pantheon operating model and an in-loop ethics layer.
Prometheus, Loki, OpenTelemetry, Grafana, and Langfuse — metrics, logs, traces, and LLM telemetry end to end. If it happened, you can see it.
Instead of one opaque mega-agent, Argus distributes responsibility across seven named domains — an explicit, inspectable operating model drawn from the mythology that gave Argus its name.
The gatekeeper. Every privileged action requires authorization — trust tiers, policy evaluation, and signed decision tokens.
The messenger. Routes communications and tasks with delivery integrity, so the right signal reaches the right destination.
The keeper of memory. Consolidates experience into durable knowledge so the system remains itself across time.
The all-seeing light. Metrics, traces, and health signals that give Argus genuine awareness of its own state.
The forge. Self-maintenance, patching, and hardening — the system that fixes the system.
The guardian of crossroads. When something goes wrong, containment and failover hold the line.
Victory, earned. Approval workflows and completion verification — work isn't done until it's verified done.
"True autonomy" at Argus means always alive, self-waking, proactive, and self-updating — with explicit governance. The canonical autonomy contract is a state machine every cycle must walk, and the gates are not optional:
"Gates-first autonomy: no self-initiated execution path bypasses the ethics layer, the execution allowlist, or approval and maintenance gates."
A canonical document defines active responsibilities, watch signals, escalation rules, completion criteria — and a silence policy. Argus knows when not to bother you.
Daily canary checks, health monitors, and stuck-cycle watchdogs catch degradation early and trigger self-repair.
Maintenance gates and operator kill switches remain authoritative at all times. Autonomy is a privilege the system continuously earns.
API-level authorization gating with a trust-tier system, policy-as-code evaluation, and HMAC-signed decision tokens. Privileged actions don't execute on good intentions — they execute on signed proof. Validation: 40/40 gap-closure checks passed.
Ten scanner modules for host intrusion detection watching the machine Argus lives on. Validation: 55/55 development checks and 10/10 post-install checks passed.
Shell execution is blocked entirely. Commands run argv-based with no shell, against an explicit allowlist of 125+ registered operations. If it isn't on the list, it doesn't run.
Merkle-chained, append-only logs with decision trace IDs stitched across the full execution path. The audit trail isn't a report — it's a property of the architecture.
Session-based chatbots reset to zero. Argus consolidates experience into five cooperating memory layers, with semantic deduplication and decay — so knowledge compounds instead of accumulating noise.
What happened — events, cycles, outcomes.
What it means — distilled facts and concepts.
How things relate — entities, links, dependencies.
What to do differently — outcome-weighted learning.
Architecture blueprints, validation evidence, and a live walkthrough are available under briefing.
Request a Technical Briefing