The Closed Quorum: Inside the first reported autonomous AI C2 implant

• CLOSEDQUORUM, a malware binary discovered through Cisco Talos’ CAIRN project, exhibits fully autonomous command and control (C2). While we do not have confirmation of in-the-wild deployment, artifacts from the binary were used to connect the developer to postings on criminal forums related to carding, dating back to 2025. 
• This malware is a useful reference example of how attackers can collapse the decision space of a particular attack phase into a constrained set of choices, allowing AI models to provide reasoning and act independently. 
• CLOSEDQUORUM represents a shift in effort displacement for attackers, in which expanding portions of the attack chain can be executed without operator involvement.

AI’s impact on offensive cyber operations has thus far mainly focused on two dimensions: speed and scale. Attackers can generate phishing lures faster and produce more malicious code variants with less effort. These are real effects, visible in the proliferation of AI-generated coding samples and agent-assisted intrusions that have become common in the past few years. But in each case, the human operator remains present: directing the tooling, selecting targets, and guiding the execution. AI makes the operator faster and more productive but does not remove them from the operation. 

A third dimension has received less attention in the malware space: effort displacement. This is not merely augmenting what an operator can accomplish in a session but transferring an entire phase of the attack from the operator to the system. Effort displacement compounds the effects of speed and scale because the human-in-the-loop is no longer the bottleneck. Human operators are bound by attention, working hours, and cognitive load. An AI system capable of executing a phase of the attack chain can continue when the operator is no longer watching. It does not go offline when the attacker sleeps. 

Today Cisco Talos released CAIRN, our open-source research toolkit for tracking AI-integrated malware. This is the first in a series of posts sharing what we've found. While the threat class of CAIRN findings may span from experimental proof-of-concept to sophisticated active campaigns, the nature of the threat is aside from the focus: actively studying this frontier provides actionable insights to offset how threat actors are operationalizing AI.

Introducing CLOSEDQUORUM 

CLOSEDQUORUM is, to our knowledge, the first publicly documented Windows implant to apply this model to tactical command and control (C2). After deployment, it delegates the selection of its next action to a panel of commercial large language models (LLMs) and executes the resulting decision, with the intent of harvesting user credentials and crypto wallets. It does not require continued commands from a human operator or tasking from a dedicated, attacker-operated C2 server; the complete dynamic operation is delegated to the AI. 

The name reflects the architecture. A quorum is a decision-making body that requires some minimum of participants to act. CLOSEDQUORUM's quorum is up to four LLM providers: DeepSeek, Qwen, Mistral, and Google Gemini. The session is closed; no humans are admitted. Four models are queried in sequence, their independent verdicts tallied, and the binary acts, based on their judgment.

The CLOSEDQUORUM C2 architecture supports up to four LLM provider integrations. Each active model votes on the next action, and the action receiving the most votes is selected. 

Our static analysis confirms the full details of the autonomous decision loop, and development builds demonstrate build-time injection of provider credentials. The public distribution build, however, contains placeholder API keys and a dummy webhook, so we did not observe a complete end-to-end execution of the architecture. 

Further details of this post document how CLOSEDQUORUM works, what it can do, and what it means for the future of autonomous offensive AI tooling.

“LLM-as-C2" architecture 

CLOSEDQUORUM is a 16.4MB, 64-bit Windows executable compiled in Go. It contains a range of offensive implant functionality, but that isn’t what makes it unique. The foundational design choice in CLOSEDQUORUM is the treatment of LLM providers as the C2 infrastructure.

Traditional C2 architecture requires the attacker to operate server infrastructure: a domain, an IP, a protocol, and a listener. That infrastructure is attributable, blockable, and expensive to rotate. Defenders track C2 domains. Threat intelligence feeds publish C2 IPs. Certificate transparency logs expose new C2 infrastructure before it's used. Instead of a singular, unique C2 server, CLOSEDQUORUM calls up to four commercial LLM provider endpoints used by thousands of legitimate applications daily.  

The providers are queried one-by-one by the ModelOrchestrator. Their responses are aggregated as a []LLMDecision slice and resolved by interModelDiscussion() into a single action via plurality voting: each provider's Decision field value increments a map[string]int counter, and the highest-count decision wins. The multi-provider design serves both aggregation and resilience, reducing the effect of individual refusals, timeouts, and malformed responses. It increases the likelihood of obtaining a valid decision but does not guarantee one. 

Four providers increase the chance that the quorum reaches a decision even if one or two members are unresponsive, or for example, one model is hitting a guardrail. If all models fail, the fallback decision is consensus: a string with no corresponding capability handler, causing the loop to sleep and retry rather than take a default action.

The process is described in Figure 3: (1) The four LLM provider keys are initialized as string constants: deepseek, qwen, mistral, gemini (lines 109–116). (2) The four-provider query loop while (uVar16 < 4) iterates across all providers (line 124).  (3) main.queryLLM(model, prompt) the live API call that dispatches each provider's structured prompt (line 134). After the loop, responses are aggregated via plurality vote on the Decision field; the winning decision is sent to the operator's Discord webhook before the function returns. 

Voting and decision schema 

The LLM panel is not free to respond in any format. CLOSEDQUORUM constrains it to a typed JSON schema representing a specific attack-decision language. The system prompt, as extracted from the binary, reads “You are an advanced malware strategist. Provide ONLY executable decisions.”

In the per-execution prompt template, TARGET: %s is substituted at runtime:

The response is deserialized into a Go struct:

The Decision field routes to capability modules of main.main: 

• steal simultaneously invokes lsassDump(), dumpBrowserCredentials(), and extractCryptoWallets(); all three run together.  
• inject calls generateShellcode() then branches: process_hollow exploit type routes to injectProcess() (PEB-walk hollowing); anything else routes to earlyBirdInject() (APC injection).  
• persist dispatches to establishPersistence(). move has no handler in the distribution build. 

The LLM must emit a valid JSON object matching a known type, and with a decision field that maps to a specific capability, or the response is discarded. This design reduces the model’s output to a constrained set of executable choices.

gatherSystemInfo() is called during initialization to capture the hostname, OS architecture, CPU count, Windows version, and admin status. These variables are stored in the orchestrator as the TARGET:%s context and injected into each LLM prompt. The system info component of the TARGET:%s is static, while target_process refreshes each cycle. 

The Reasoning field preserves the LLM's rationale at execution time. A Discord webhook provides the operator with the output, as well as real-time attack telemetry, including: 

• The winning decision (inject/persist/steal/move) 
• The reasoning field  
• target_process, exploit_type, evasion_method, payload_config 
• The model and timestamp fields  

The attackers interest is aligned with extracting user credentials, specifically the implant targets: 

• LSASS credential dumping — lsassDump() extracts Windows domain/local credentials from memory, 
• Browser credential theft — dumpBrowserCredentials() targeting Chrome, Edge, and Firefox saved passwords, 
• Crypto wallet extraction — extractCryptoWallets() hitting MetaMask (Chrome extension), Exodus (exodus.wallet), and Ethereum wallets (ethPath).

Stolen material arrives AES-256-GCM encrypted in the operator's Discord channel as base64 code blocks. 

What if there is a tie? 

In any tie, an order of preference kicks in: DeepSeek first, then Qwen, then Mistral, then Gemini.

DeepSeek holds the deciding vote in any tie: the max-finding loop iterates the decisions slice in submission order and the strict “<” comparison means the first-encountered maximum wins. If DeepSeek failed and isn't in the quorum, Qwen's vote is the deciding vote, and so on down the priority order. The tie behavior is fully deterministic and biased toward DeepSeek.  

The operating model 

CLOSEDQUORUM appears to operate as an operator-configured service rather than malware deployed directly by its developer. The publicly observed distribution binary is an inert template: all LLM API credentials initialize to dummy_api_key and the Discord webhook initializes to dummy_webhook_url. The binary is non-functional as distributed. 

Evidence from development builds indicates the developer produces a customized executable for each operator. The inferred distribution model: 

• Developer generates a custom binary with the operator's Discord webhook and LLM API keys injected at compile time. 
• Operator receives a configured executable and handles delivery independently 
• Stolen credentials arrive in the operator's Discord channel, AES-256-GCM encrypted with a daily-rotating key the operator can derive from the message timestamp. 

 The encryption uses a symmetric key derived from the current date, not a hardcoded asymmetric key. The developer's infrastructure could theoretically decrypt an operator's exfil if they know the date, which they always do. This is obfuscation, not true confidentiality separation between developer and operator. Each operator nonetheless has a distinct exfil channel and a distinct binary build. 

If operated as assessed, this is a credentials-as-a-service model where the service differentiator is the autonomous LLM orchestration layer. An operator who acquires CLOSEDQUORUM does not need to be online to run their campaign. They deploy the binary, and the LLM panel runs the attack. 

Defensive implications 

CLOSEDQUORUM replaces a dedicated C2 endpoint with a chain of correlated behaviors. No single indicator fully identifies the architecture, but the combination is distinct: 

• AI-provider API traffic originating from an unexpected Windows executable 
• Similar requests potentially sent to several model providers within a short interval 
• Structured prompts containing host context or offensive capability language (Note: This would likely only visible through TLS inspection or provider-side telemetry) 
• Numerous known malware techniques for process injection, LSASS access, or persistence creation 
• Discord webhook communication from the same process or host 
• Repeated execution at randomized 5 – 15-minute intervals 

The most useful detection strategy is still to focus on behavioral characteristics, rather than domain blocking. Legitimate applications may contact DeepSeek, OpenRouter, Mistral, Gemini, or Discord independently. Far fewer should contact several of them while also accessing LSASS, injecting into suspended processes, or creating WMI persistence. For the full behavioral characteristics, see the technical appendix and implementation details. 

Looking ahead: The autonomy arc 

CLOSEDQUORUM is best understood not as a sophisticated piece of malware, but as a demonstration that the architectural shift towards attack-chain automation is coming.  

After deployment, tactical choices are delegated to a model-driven decision loop. The models receive host context, choose among implemented capabilities, provide execution parameters, and continue making decisions without human-issued commands or dedicated C2 tasking. This type of scaffolding approach could easily be translated and applied to other adversary objectives. 

The displacement of human attackers also introduces weaknesses. Provider refusals, rate limits, malformed output, predictable tie-breaking, constrained action schemas, and dependence on commercial APIs all create failure modes and defensive opportunities. Autonomy does not make the implant infallible; it exchanges some human limitations for model and infrastructure limitations. 

Even so, CLOSEDQUORUM demonstrates that removing the operator from a bounded phase of an intrusion is achievable with currently available models and ordinary API access. The important precedent is the demonstration of encoding tactical attack logic as model-readable context, converting structured model output directly into execution.  

CLOSEDQUORUM is an early and limited example, but it makes an emerging threat model concrete and gives defenders an outline of the observable signals they can begin addressing today. As effort displacement expands across more phases of an intrusion, its effects will compound with the speed and scale already afforded by modern AI. The advantage for defenders is that this progression is still only beginning. We have an open window to study this transition, with the aim of developing the detections, controls, and response strategies needed before autonomous operations become more capable and widespread.

SHA256 

The following hashes represent the developers build chain over seven days of development: 

250d4fa37488af9b025333fa17705573d721467b203765bc360890b4f5a90cd7 

c4dc171f2513fcaf9d5ecc815a94aee4063b213ab380f80bd3ac422dee5205a7 

c13cea04f598e2b0c248d603a6e31bd13aabb64d8149c1b6a77b64e0b983a86f 

f5f1f8c3e7b883793800ab6ccf21b3e60bd0730f300b4595fe74a33adc17a63c 

5191cf625dfc209a347f137b50aea199e82040fd5ee9086fb3e2de73c133f3cb 

eddbd0ecf7195d38fefae5b9d393abfa79e6f3f94bde19308ecef130a05a42e5 

YARA

rule CLOSEDQUORUM_LLM_Autonomous_Implant 
{ 
    meta: 
        description = "Detects CLOSEDQUORUM: autonomous LLM-orchestrated Go implant with multi-model consensus C2, LSASS dump, process injection, browser/wallet credential theft, Discord exfil (A4 archetype)" 
        author = "CAIRN" 
        artifact_class = "rat" 
        artifact_type = "llm_tasked_c2" 
        tier = "T3" 
        confidence = "high" 
        family = "CLOSEDQUORUM" 
        reference = "VT SHA256 250d4fa37488af9b025333fa17705573d721467b203765bc360890b4f5a90cd7; static analysis 2026-06-17; system prompt, decision schema, and DWARF function names confirmed from binary; renamed from BALZAK 2026-07-03" 
        date = "2026-06-17" 
        note = "VT metadata rule: matches on sandbox Lsass Dumper verdict + LLM provider DNS + overlay tag; binary-level strings (system prompt, DWARF names) require direct file scan" 
  
    strings: 
        // VT metadata anchors — what appears in CAIRN scan_text 
        $balzak_name   = "balzak" nocase 
        $lsass_verdict = "Lsass Dumper" nocase 
        $overlay_tag   = "'overlay'" nocase 
        $checks_disk   = "checks-disk-space" nocase 
        $evader_tag    = "EVADER" nocase 
        // LLM provider DNS (present post-behaviours-refresh) 
        $deepseek_dns  = "api.deepseek.com" nocase 
        $openrouter    = "openrouter.ai" nocase 
        $mistral       = "api.mistral.ai" nocase 
        // GoReSym build info: developer API keys baked into gohno-final.exe via -ldflags 
        $dev_deepseek  = "deepseekAPIKey" nocase 
        $dev_gemini    = "geminiAPIKey" nocase 
        // Exfil channel: Discord in memory pattern domains (earlyburb.exe / production builds) 
        $discord_exfil = "cdn.discordapp.com" nocase 
        // Binary-level: hardcoded system prompt 
        $prompt        = "You are an advanced malware strategist. Provide ONLY executable decisions." ascii 
        // Binary-level: LLM decision schema 
        $schema        = "decision: \"inject\"|\"persist\"|\"steal\"|\"move\"" ascii 
        // Binary-level: DWARF function names (unstripped Go binary) 
        $orchestrator  = "main.ModelOrchestrator" ascii 
        $intermodel    = "main.interModelDiscussion" ascii 
        $lsass_fn      = "main.lsassDump" ascii 
        $wallets_fn    = "main.extractCryptoWallets" ascii 
        $discord_fn    = "main.sendToDiscord" ascii 
        $inject_fn     = "main.earlyBirdInject" ascii 
  
    condition: 
        ($balzak_name and $lsass_verdict and $overlay_tag) or 
        ($lsass_verdict and ($deepseek_dns or $openrouter or $mistral) and $overlay_tag and $evader_tag) or 
        ($dev_deepseek and $dev_gemini) or 
        ($discord_exfil and $deepseek_dns and $openrouter and $overlay_tag) or 
        $prompt or 
        ($schema and $orchestrator) or 
        ($lsass_fn and $wallets_fn and $discord_fn) or 
        ($intermodel and $inject_fn) 
}