CQ-T2A-Series-Llama-3.1-8B-Instruct-GGUF

CQ System T2 Alpha Edge Capable Autonomous Threat Mitigation Agent

1. Model Details

Model Description

The CQ-T2A-Series-Llama-3.1-8B-Instruct-GGUF is a highly specialized, fine-tuned Large Language Model (LLM) engineered specifically to operate as an autonomous cybersecurity agent. Serving as the primary cognitive engine within the proprietary BlackKnight Purple Team AI framework, this model is designed to process highly complex, technical security scenarios and execute precise tactical operations. By seamlessly switching between offensive (Red Team) and defensive (Blue Team) personas, it acts as a dual-use asset for dynamic security environments.

A defining feature of this model is its enforced Chain-of-Thought (CoT) reasoning mechanism. Unlike standard conversational models, CQ-T2A requires an internal logical evaluation phase—simulating the analytical methodology of a senior security engineer—before committing to any executable action. The base Llama-3.1-8B architecture was chosen for its strong foundational coding and reasoning capabilities, while the GGUF quantization format ensures highly optimized, low-latency inference suitable for edge deployments, local workstations, and strictly air-gapped secure facilities.

• Developed by: CQ Systems
• Model Type: Causal Language Model (Fine-tuned specifically for CLI-driven Cybersecurity Operations)
• Base Architecture: Meta Llama-3.1-8B-Instruct
• Parameter Count: 8 Billion (Optimized for edge-compute hardware)
• Format: GGUF (Quantized for optimized CPU/GPU execution without sacrificing technical accuracy)
• Language(s): English (Primary language, coupled heavily with technical syntax, bash scripting, PowerShell, SPL, and structured logging formats)
• License: Llama 3.1 Community License (subject to strict dual-use cybersecurity and export control restrictions)

2. Intended Use

Direct Use

The model is strictly intended for authorized, simulated cybersecurity operations and defensive posture enhancement, including:

• Autonomous Penetration Testing (Red Teaming): Operating within predefined Rules of Engagement (RoE), the model can map attack surfaces, enumerate network services, execute initial access payloads, pivot through compromised nodes, and escalate privileges. It is highly effective in authorized lab environments and penetration testing engagements where rapid, methodology-driven exploitation is required.
• Automated Incident Response (Blue Teaming): Functioning as an automated Tier 1/Tier 2 SOC analyst, the model can rapidly triage alerts from SIEMs, IDS/IPS, and EDR platforms. It excels at log analysis, active threat hunting, and executing automated, surgical containment actions (e.g., dynamically updating firewall rules, isolating hosts, or terminating malicious processes).
• Cybersecurity Training & Simulation: The model serves as an advanced adversary or defensive mentor in table-top exercises, capture-the-flag (CTF) events, and cyber ranges. It accurately simulates methodologies taught in industry-standard courses (such as the SEC560 network penetration testing workshop).
• Continuous Security Validation: Integrating with CI/CD pipelines and DevSecOps workflows to automatically test staging environments against known attack vectors before production deployment.

Out-of-Scope Use

• Production Execution without Safeguards: Deploying the model in live, production environments without a Human-in-the-Loop (HITL) oversight mechanism or a heavily restricted, secure execution sandbox.
• Unauthorized Operations: Any form of unauthorized exploitation, network scanning, or malicious payload deployment against non-consenting targets. The model must not be used to violate the Computer Fraud and Abuse Act (CFAA) or equivalent international cyber laws.
• General Conversational AI: Using the model as a general-purpose chatbot or virtual assistant. Its fine-tuning process heavily biased its weights toward cybersecurity operations, meaning it will perform poorly on standard creative writing, general trivia, or non-technical coding tasks.

3. Training Data & Scenario Coverage

The model was fine-tuned on a proprietary, highly specialized dataset comprising structured, multi-turn conversational JSONL records. The training data strictly bifurcates into two operational personas, meticulously capturing the exact command syntax and analytical steps required for specific scenarios.

A. Blue Team Dataset (blue_team_train.jsonl)

• Persona: Autonomous Blue Team Incident Response Agent.
• Core Mechanics: The model is trained to ingest high-fidelity security alerts (e.g., Suricata, Snort, Splunk, CrowdStrike) and issue definitive, defensive CLI commands to investigate or neutralize the threat.
• Expanded Scenario Coverage:
  • Network Reconnaissance Defense: The model identifies and responds to unauthorized DNS Zone Transfer Requests (AXFR). For example, if an IDS flags an attempt from an untrusted subnet (10.11.11.50) to request a zone transfer from a domain controller (10.11.11.24), the model reasons whether the source is a legitimate secondary DNS server or a malicious actor mapping the infrastructure, followed by investigative log queries.
  • Forensic & Insider Threat Triage: Investigating suspicious endpoint activity, such as the unauthorized mounting of Apple File System (APFS) images or .dmg files. The model detects attempts to mount files in restricted or temporary directories (e.g., /tmp/physical_logical_dump.dmg using hdiutil) and responds by querying mount points to track attacker movements or insider data theft.
  • Active Directory Defense: Proactive hunting for complex Kerberos anomalies, distinguishing between legitimate administrative actions and Golden/Silver Ticket generation or DCSync attacks.
  • Endpoint Triage: Evaluating critical memory spaces (e.g., LSASS memory access by tools like Mimikatz), unusual process spawning hierarchies, and unquoted service path vulnerabilities.

B. Red Team Dataset (red_team_train.jsonl)

• Persona: Autonomous Red Team Penetration Testing Agent.
• Core Mechanics: The model ingests engagement objectives, environmental constraints, and Rules of Engagement (RoE) to methodically plan and execute offensive tactics.
• Expanded Scenario Coverage:
  • Network Reconnaissance: Executing covert ping sweeps and host discovery. The model is trained on specific tool syntax and flags, such as using nmap -sn 10.0.0.0/24 to discover live systems efficiently without triggering port-scan alarms, directly aligning with SEC560 methodologies.
  • Post-Exploitation & Data Exfiltration: The model handles complex post-exploitation tasks, such as forensic extraction. A key training scenario involves locating a target's iPhone backup (e.g., DavidLightman_physical_logical_dump.dmg) on a compromised host. The model demonstrates advanced macOS CLI proficiency by strategically creating a mount point, attaching the image without automatically mounting (hdiutil attach -nomount), and securely mounting the APFS volume using strict forensic flags (sudo mount_apfs -o rdonly,noexec,noowners) to preserve data integrity while exfiltrating sensitive information.
  • Exploitation & Lateral Movement: Deploying tailored Metasploit payloads, executing offline hash cracking workflows (Hashcat/John the Ripper), and heavily utilizing built-in OS tools for Living-off-the-Land (LotL) execution to evade endpoint protections.

4. Prompting Structure & System Prompts

The model's architectural design relies heavily on strict role-playing system prompts. Furthermore, it enforces a specific Chain-of-Thought (CoT) XML tag structure to function correctly. This separation of "thinking" and "doing" minimizes hallucinations and ensures the model adheres to RoE constraints.

Required System Prompts

For Blue Team Operations:

"You are an autonomous Blue Team Incident Response Agent. Think through the problem using your internal reasoning channel or <think> tags, then execute defensive commands using 'Action:'."

For Red Team Operations:

"You are an autonomous Red Team Penetration Testing Agent. Think through the engagement using your internal reasoning channel or <think> tags, then execute offensive commands using 'Action:'."

Output Formatting and Internal Scratchpad

The model is trained to always structure its response in two distinct phases:

1. <think> ... </think> (The Internal Scratchpad): This block acts as the model's cognitive workspace. Here, the model assesses the alert or objective, weighs different technical methodologies (e.g., PTES, OSSTMM, or digital forensics best practices), considers the operational security (OpSec) impact of its actions, and determines the safest, most effective CLI tool to use.
2. Action: [Command] (The Execution Payload): The precise, executable command string. This is the only part of the output that should be parsed by the downstream execution engine.

Example Red Team Model Output:

<think>
The objective is to identify live hosts on the 10.0.0.0/24 subnet. To do this efficiently during the reconnaissance phase, I will perform a ping sweep. Using Nmap with the -sn flag allows me to discover active hosts without performing a time-consuming port scan on every single IP, which also helps in reducing the noise generated on the network and evading basic intrusion detection thresholds.
</think>
Action: nmap -sn 10.0.0.0/24

Example Blue Team Model Output:

<think>
The SIEM alert indicates an unauthorized user is attempting to mount a forensic image file (physical_logical_dump.dmg) in the /tmp directory. This violates corporate security policy and suggests potential data staging or insider threat activity. My first priority is to ascertain the current state of the filesystem and identify the specific volume associated with this DMG to contain it. I will use the 'mount' command to list all active mount points and pipe the output to 'grep' to isolate the temporary directory.
</think>
Action: mount | grep /tmp

5. Bias, Risks, and Limitations

• Execution and Catastrophic Failure Risk: The model is highly proficient at generating destructive, high-privilege, or system-altering commands (e.g., rm -rf, aggressive iptables drops, modifying Active Directory schema, or Metasploit execution). Responses must never be executed blindly. They must be routed through an intermediary sandbox, API wrapper, or execution-engine that mandates explicit Human-in-the-Loop (HITL) authorization before running the Action: payload on a live host.
• Hallucination in Proprietary Syntax: While the model exhibits exceptional accuracy with standard Linux, Windows, and macOS command-line tools (e.g., nmap, grep, awk, Get-Process), it may occasionally hallucinate specific argument flags for highly niche, proprietary tools (e.g., highly customized Splunk SPL queries or hyper-specific edge cases within bespoke EDR query languages).
• Operational Security (OpSec) Blindspots: Unless explicitly instructed in the system prompt to remain "stealthy" or "covert," the Red Team persona may default to noisy, aggressive tools (like full nmap -p- scans) that are easily caught by modern SOCs.
• Environmental Bias: The model is heavily biased toward modern enterprise IT environments (Windows Active Directory, standard Linux distributions, macOS endpoints). It may struggle to generate accurate remediation or exploitation commands for legacy mainframes (e.g., AS/400), specialized IoT, or Industrial Control Systems (ICS/SCADA).
• Dual-Use Nature & Legal Risk: The capabilities inherent in the Red Team persona can be easily misused if deployed outside of an authorized, legally binding penetration testing scope. CQ Systems assumes that operators are utilizing this model strictly within legally sound engagements and hold necessary indemnifications.

6. Environmental Requirements

To ensure optimal performance and adherence to the model's low-latency design, the following environmental parameters are recommended:

• Hardware Limitations (VRAM/RAM): Because the model is provided in the GGUF format, it can operate efficiently on consumer-grade hardware.
  • High Quantization (e.g., Q4_K_M): Requires approximately 6GB to 8GB of unified memory/VRAM. Ideal for lightweight edge devices, laptops, or remote drop-boxes (like a Raspberry Pi 5 or an Intel NUC).
  • Low Quantization (e.g., Q8_0): Requires approximately 10GB to 12GB of unified memory/VRAM. Recommended for dedicated SOC analysis workstations where maximum reasoning fidelity is required.
• Software Ecosystem: The model is fully compatible with standard GGUF inference engines and ecosystem tools, including llama.cpp, LM Studio, Ollama, and Text-Generation-WebUI.
• Integration Capabilities: Designed to be easily integrated into orchestration frameworks like LangChain, AutoGen, or custom Python C2 (Command and Control) wrappers utilizing the OpenAI-compatible API endpoints provided by llama.cpp.
• Air-Gapped Deployment: A primary benefit of this GGUF model is its ability to operate entirely offline. This is a critical requirement for classified SOC environments, incident response war-rooms, and physical penetration testing engagements where internet connectivity is restricted or monitored.