Cybersecurity & AI Automation Wiki

Introduction

Cybersecurity in 2026 is no longer just firewalls and manual pentests — it is AI-native. Attackers use LLM agents to automate reconnaissance, phishing, and exploit development; defenders use the same technology to find bugs faster, triage alerts, and auto-generate reports.

This wiki bridges both worlds: core security fundamentals, the current AI security landscape, step-by-step guides to build your own AI agents on a local PC (auto-scan, auto-exploit, auto-report, social-media posting, PC voice control, WordPress writing), and a career roadmap.

The CIA Triad

Three pillars every security control — human or AI — ultimately protects:

Best Practices

State of AI Security in 2026

The biggest shift in the last two years: security tooling moved from chatbots that suggest commands to autonomous agents that plan, execute, and verify. Research agents now complete real CTF/HTB challenges end-to-end with minimal human input.

AI Pentest & Security Tools (2026)

Reference list: the LLM4Pentest GitHub repository tracks dozens of research agents (PentestAgent, RefPentester, PENTESTAGENT, and more).

Attacking AI & LLM Systems

If you want to secure AI in 2026, learn the OWASP Top 10 for LLM Applications and the MITRE ATLAS matrix:

How to Build Your Own AI — Full Local PC Guide

You can run a full AI stack 100% offline on a mid-range PC. No cloud, no per-token cost, full privacy.

Step 1 — Hardware you need

Step 2 — Install Ollama (easiest engine)

bash# Linux / WSL
curl -fsSL https://ollama.com/install.sh | sh

# Pull a general model + a reasoning model
ollama pull llama3.1
ollama pull qwen3:14b
ollama pull deepseek-r1:14b

# Chat in the terminal
ollama run llama3.1

Windows/macOS: download the installer from ollama.com. Alternative GUIs: LM Studio (beginner-friendly, port 1234) and Jan (offline/private). Ollama exposes an OpenAI-compatible API on http://localhost:11434.

Step 3 — Talk to it from Python

pythonimport ollama

resp = ollama.chat(
    model="llama3.1",
    messages=[{"role": "user", "content": "Explain the OWASP Top 10 for LLMs in 5 bullets"}],
)
print(resp["message"]["content"])

Step 4 — Give it memory & tools (make it an agent)

A “chatbot” becomes an agent when you add three things: tools (functions it can call), memory (conversation/state), and a loop (plan → act → observe → repeat). The sections below build real agents on exactly this pattern.

Step 5 — Pick an agent framework

bashpip install ollama langgraph langchain crewai smolagents openai-agents

Build an AI Agent for Auto-Scan / Find Bugs / Exploit / Report

This is a ReAct (Reason + Act) agent: the LLM decides which security tool to run, executes it, reads the output, and decides the next step — then writes a report. It uses a local Ollama model and standard tools.

The agent

pythonimport subprocess, json, ollama, datetime

TARGET = "http://127.0.0.1:8080"   # AUTHORIZED LAB TARGET ONLY
MODEL  = "llama3.1"

def run(cmd, timeout=180):
    """Run a shell command safely and return trimmed output."""
    try:
        p = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
        return (p.stdout or p.stderr or "(no output)")[-5000:]
    except subprocess.TimeoutExpired:
        return "[timeout]"

TOOLS = {
    "nmap":   lambda t: run(f"nmap -sV -sC -Pn {t}"),
    "httpx":  lambda t: run(f"httpx -u {t} -status-code -title -tech-detect -silent"),
    "nuclei": lambda t: run(f"nuclei -u {t} -severity critical,high,medium -silent -no-color"),
    "ffuf":   lambda u: run(f"ffuf -u {u}/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -mc 200,301 -s -t 40"),
    "sqlmap": lambda u: run(f"sqlmap -u {u} --batch --level 1 --risk 1 --banner"),
    "done":   lambda r: r,
}

SYSTEM = f"""
You are an autonomous penetration-testing agent with authorized access to: {TARGET}.
Available tools: {', '.join(TOOLS)}.
Loop rules:
1. Reply ONLY with valid JSON: {{"tool": "name", "arg": "value"}} to run a tool.
2. When you have enough evidence, reply: {{"tool": "done", "arg": "your final report text"}}.
3. Chain results: recon -> enumerate -> test -> verify -> report.
4. Never target anything other than {TARGET}.
"""

def agent():
    history = [{"role": "system", "content": SYSTEM}]
    for step in range(12):
        r = ollama.chat(model=MODEL, messages=history)
        reply = r["message"]["content"].strip()
        history.append({"role": "assistant", "content": reply})
        try:
            # tolerate markdown fences around the JSON
            reply = reply.replace("```json","").replace("```","").strip()
            action = json.loads(reply)
        except Exception:
            action = {"tool": "done", "arg": "Agent produced invalid JSON. Last reply:\n" + reply}
        tool, arg = action["tool"], action["arg"]
        if tool == "done":
            return arg
        out = TOOLS.get(tool, lambda a: f"[unknown tool {tool}]")(arg)
        history.append({"role": "user", "content": f"tool {tool}({arg}) output:\n{out}"})
    return "Agent reached step limit without a final report."

if __name__ == "__main__":
    report = agent()
    ts = datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S")
    path = f"pentest_report_{ts}.md"
    open(path, "w").write(f"# Automated Pentest Report\n\nTarget: {TARGET}\n\n{report}\n")
    print(f"[+] Report written to {path}")

Upgrade it to a multi-agent team

Tip: replace the single-loop above with CrewAI or LangGraph so each role is a separate agent with its own system prompt and memory. Add a human-in-the-loop gate before any exploit step.

Build an Agent That Auto-Posts to All Social Media

One agent that drafts platform-optimized copy with a local LLM, then publishes to every platform through their APIs. Store credentials in environment variables, never in code.

Adapter pattern (one interface, many platforms)

pythonimport os, ollama

class PostClient:
    def publish(self, text, media=None):
        raise NotImplementedError

# ---- X / Twitter (free API tier via tweepy) ----
class XClient(PostClient):
    def __init__(self):
        import tweepy
        self.client = tweepy.Client(
            bearer_token=os.environ["X_BEARER"],
            consumer_key=os.environ["X_API_KEY"],
            consumer_secret=os.environ["X_API_SECRET"],
            access_token=os.environ["X_ACCESS"],
            access_token_secret=os.environ["X_ACCESS_SECRET"],
        )
    def publish(self, text, media=None):
        self.client.create_tweet(text=text[:280])
        return "posted to X"

# ---- LinkedIn (OAuth2 via requests) ----
class LinkedInClient(PostClient):
    def __init__(self):
        self.token = os.environ["LINKEDIN_TOKEN"]
        self.person = os.environ["LINKEDIN_PERSON_ID"]
    def publish(self, text, media=None):
        import requests
        r = requests.post("https://api.linkedin.com/v2/ugcPosts",
            headers={"Authorization": f"Bearer {self.token}"},
            json={"author": f"urn:li:person:{self.person}",
                  "lifecycleState": "PUBLISHED",
                  "specificContent": {"com.linkedin.ugc.ShareContent": {
                      "shareCommentary": {"text": text},
                      "shareMediaCategory": "NONE"}}})
        r.raise_for_status(); return "posted to LinkedIn"

# ---- Facebook / Instagram (Meta Graph API) ----
class MetaClient(PostClient):
    def __init__(self):
        self.token = os.environ["META_TOKEN"]
        self.page = os.environ["META_PAGE_ID"]
    def publish(self, text, media=None):
        import requests
        r = requests.post(f"https://graph.facebook.com/v20.0/{self.page}/feed",
                          data={"message": text, "access_token": self.token})
        r.raise_for_status(); return "posted to Facebook"
    def photo(self, path, caption):
        import requests
        r = requests.post(f"https://graph.facebook.com/v20.0/{self.page}/photos",
                          files={"source": open(path,"rb")},
                          data={"caption": caption, "access_token": self.token})
        r.raise_for_status(); return "posted image to Instagram/Facebook"

# ---- Threads / Mastodon (ActivityPub) ----
class MastodonClient(PostClient):
    def __init__(self):
        from mastodon import Mastodon
        self.m = Mastodon(access_token=os.environ["MASTODON_TOKEN"],
                          api_base_url="https://mastodon.social")
    def publish(self, text, media=None):
        self.m.status_post(text); return "posted to Mastodon"

# ---- The orchestrating agent ----
def draft(topic, platform, tone="professional"):
    prompt = (f"Write a {platform} post about: {topic}. Tone: {tone}. "
              "Include hashtags. Keep it concise and engaging.")
    r = ollama.chat(model="llama3.1",
                    messages=[{"role": "user", "content": prompt}])
    return r["message"]["content"].strip()

def post_everywhere(topic):
    text = draft(topic, "social media")
    for name, client in {"x": XClient(), "linkedin": LinkedInClient(),
                         "facebook": MetaClient(), "mastodon": MastodonClient()}.items():
        try:
            print(client.publish(text))
        except Exception as e:
            print(f"[!] {name} failed: {e}")

if __name__ == "__main__":
    post_everywhere("3 lessons from the 2026 AI security landscape")

Build an AI That Controls Your PC & Talks to You

A voice assistant that listens, understands intent via a local LLM, speaks back, and executes actions: shutdown, restart, open files, play videos, run web searches, or read today’s trading topics.

Install the pieces

bashpip install SpeechRecognition pyttsx3 pyaudio ollama yfinance feedparser requests
# Linux audio deps:
apt install portaudio19-dev espeak  # pyttsx3 espeak for TTS

The assistant

pythonimport os, subprocess, webbrowser, speech_recognition as sr
import pyttsx3, ollama, yfinance as yf, feedparser, json

MODEL = "llama3.1"

def speak(text):
    e = pyttsx3.init(); e.say(text); e.runAndWait()

def listen():
    r = sr.Recognizer()
    with sr.Microphone() as src:
        r.adjust_for_ambient_noise(src)
        print("Listening…")
        audio = r.listen(src)
    return r.recognize_google(audio)   # swap with whisper for offline

def interpret(cmd_text):
    """Map natural language to a structured action via a local LLM."""
    prompt = f'''Classify this command into JSON with keys: action, target.
Actions allowed: shutdown, restart, open_file, play_video, web_search, trading_topics, open_app, none.
Command: "{cmd_text}"
Reply with JSON only.'''
    raw = ollama.chat(model=MODEL, messages=[{"role":"user","content":prompt}])
    out = raw["message"]["content"].strip().replace("```json","").replace("```","")
    try: return json.loads(out)
    except Exception: return {"action":"none","target":""}

def trading_topics():
    """Pull today's trending tickers and market movers."""
    rows = []
    for sym in ["SPY","QQQ","NVDA","AAPL","TSLA","BTC-USD"]:
        t = yf.Ticker(sym).fast_info
        try: rows.append(f"{sym}: {t.last_price:.2f}")
        except Exception: rows.append(f"{sym}: n/a")
    return "Today's trading snapshot — " + ", ".join(rows)

def execute(act):
    a, t = act["action"], act["target"]
    if a == "shutdown":    os.system("systemctl poweroff")
    elif a == "restart":   os.system("systemctl reboot")
    elif a == "open_file": os.system(f'xdg-open "{t}"')
    elif a == "play_video": webbrowser.open(f"https://www.youtube.com/results?search_query={t.replace(' ','+')}")
    elif a == "web_search": webbrowser.open(f"https://www.google.com/search?q={t.replace(' ','+')}")
    elif a == "trading_topics":
        speak(trading_topics()); return
    elif a == "open_app":  os.system(f'xdg-open "{t}"')
    else:
        speak("I did not understand that command."); return
    speak(f"Done: {a} {t}")

if __name__ == "__main__":
    speak("Hi, I am your assistant. What do you need?")
    while True:
        try:
            text = listen()
            print("You said:", text)
            if "exit" in text.lower() or "quit" in text.lower(): break
            act = interpret(text)
            execute(act)
        except sr.UnknownValueError:
            speak("Sorry, I did not catch that.")
        except KeyboardInterrupt:
            break

Build an AI Agent That Writes WordPress Posts for More Reach

Uses the WordPress REST API (with an Application Password) plus a local LLM to research a keyword, draft an SEO-optimized post, add tags/categories, and publish on a schedule.

Enable API access

1. WordPress → Users → Profile → Application Passwords → generate one.
2. Keep WP_URL, WP_USER, WP_APP_PASSWORD in env vars.

The writer agent

pythonimport os, requests, ollama

WP = os.environ["WP_URL"].rstrip("/")
AUTH = (os.environ["WP_USER"], os.environ["WP_APP_PASSWORD"])

def research(keyword):
    """Have the LLM outline SEO structure: title, headings, keywords, meta."""
    prompt = f'''You are an SEO expert. For the keyword "{keyword}",
return JSON: {{"title","slug","excerpt","tags":[],"categories":[ids],
"body_markdown","meta_description","focus_keyword"}}. Write a full 800-word article.'''
    r = ollama.chat(model="llama3.1", messages=[{"role":"user","content":prompt}])
    import json
    return json.loads(r["message"]["content"].strip().replace("```json","").replace("```",""))

def publish(article, status="draft"):
    data = {
        "title": article["title"],
        "slug": article["slug"],
        "excerpt": article["excerpt"],
        "content": article["body_markdown"],   # enable a markdown plugin or convert to HTML
        "status": status,
        "tags": article.get("tags", []),
        "categories": article.get("categories", []),
        "meta": {"rank_math_focus_keyword": article.get("focus_keyword","")},
    }
    r = requests.post(f"{WP}/wp-json/wp/v2/posts", auth=AUTH, json=data)
    r.raise_for_status()
    return r.json()["link"]

if __name__ == "__main__":
    art = research("cybersecurity career roadmap 2026")
    link = publish(art, status="draft")   # review before switching to "publish"
    print("Draft created:", link)

Maximize reach

• Schedule a batch of keyword drafts weekly; review and publish on a calendar.
• SEO plugins (Rank Math / Yoast) read the meta fields you set above.
• Internal linking — prompt the LLM to link 3 older posts in each new article.
• Repurpose — feed the same draft to the social-media agent to auto-post snippets everywhere.
• Indexing — ping Google Search Console / Bing Webmaster after publishing.

Web Attacks

Network Attacks

Social Engineering

Malware

Skills & Knowledge for the Future (2026+)

Companies now hire for AI security engineers and security automation engineers alongside traditional roles. The winning combination is classic security depth + AI fluency.

Career Roadmap & Certifications

Job-ready checklist

Common Tools

Frameworks & Standards

Glossary