Found a way to fix Agent Zero slowing down / VRAM crashing over time (without breaking the core container)

[zayzay109]

Hey everyone. I'm still somewhat new to this side of the AI world and learning as I go, but I ran into a massive wall with Agent Zero lately that I managed to fix without deleting any data.

I’ve been running AZ heavily for a few weeks, and recently the web UI started freezing up on boot, hanging, and taking 15+ seconds just to load the sidebar.

It turns out, Agent Zero's frontend tries to render the metadata of every single .json file sitting in your /a0/data/api/chats/ directory simultaneously. When I checked mine, I had hundreds of thick chats causing over 100 million tokens of JSON data to hit the DOM. The UI was essentially choking on weeks of old context it didn't even need to be rendering visibly.

I definitely didn't want to "monkey patch" or hack the core Agent Zero UI code because I want my container to survive future updates safely, and I absolutely did not want to lose my actual chat history.

The Fix: Visual Archiving

If you check the official Agent Zero Plugin Hub, there is a very popular UI plugin available to everyone called Chat Archive. Many of you are probably already using it! (Note: It's not a miraculous find for me, just one of the common plugins available. A second popular one we use for other workflows is the YouTube Transcriber.) When installed, Chat Archive hijacks the frontend data store and strips "archived" chats from the DOM before they render, natively stopping the UI bleed.

To automate it, I wrote a standalone Python script to act as a background janitor. It groups your chats by age and silently injects the old ones into the plugin's hidden database.

How it works seamlessly:

• 0-7 days old: Kept exactly where they are in the active sidebar.
• 7-3000 days old: Kept on the disk unharmed, but automatically flagged as "archived" in the plugin database. They fade away from your sidebar, stopping the lag entirely.
• Important Note on Restoration: If you change your retention days later, the script will not automatically un-archive chats. The script is a one-way archiver.
• To restore: You just click the "Archive box" icon next to New Chat in her UI, and click restore. It pops right back into your active list!

The Script

If you want to use it, grab the plugin from the link above, and then drop this Python file anywhere inside your container (I put mine at /a0/usr/scripts/context_pruner.py):

#!/usr/bin/env python3
"""
context_pruner.py
Visually archives obsolete chats into a0-chat-archive.
"""

import datetime as dt, json, os, argparse, time
from pathlib import Path

DEFAULT_CHATS_ROOT = Path("/a0/usr/chats")
DEFAULT_PLUGIN_ARCHIVE = Path("/a0/usr/plugins/chat_archive/data/archive.json")
DEFAULT_HOT_DAYS = 7 # Adjust to your liking

def get_true_age(chat_json: Path, now: dt.datetime) -> float:
    try:
        with open(chat_json, 'r', encoding='utf-8') as f:
            data = json.load(f)
    except Exception:
        return float('inf')
        
    last_msg = data.get("last_message")
    if last_msg:
        try:
            last_ts = dt.datetime.fromisoformat(last_msg).astimezone(dt.timezone.utc)
            return max(0.0, (now - last_ts).total_seconds() / 86400.0)
        except Exception:
            pass
            
    try:
        mtime = dt.datetime.fromtimestamp(chat_json.stat().st_mtime, tz=dt.timezone.utc)
        return max(0.0, (now - mtime).total_seconds() / 86400.0)
    except Exception:
        return float('inf')

def archive_visually_in_plugin(plugin_json: Path, chat_id: str, chats_root: Path) -> bool:
    try:
        import fcntl
    except ImportError:
        fcntl = None
        
    plugin_json.parent.mkdir(parents=True, exist_ok=True)
    
    lock_path = plugin_json.with_suffix('.lock')
    lock_fd = None
    if fcntl:
        try:
            lock_fd = os.open(str(lock_path), os.O_CREAT | os.O_RDWR)
            fcntl.flock(lock_fd, fcntl.LOCK_EX)
        except Exception:
            lock_fd = None

    try:
        data = {}
        if plugin_json.exists():
            try:
                with open(plugin_json, "r", encoding="utf-8") as f:
                    data = json.load(f)
            except Exception:
                pass
                
        if chat_id in data:
            return False

        chat_json_path = chats_root / chat_id / "chat.json"
        actual_name = f"Chat {chat_id} (AutoPruned)"
        if chat_json_path.exists():
            try:
                with open(chat_json_path, "r", encoding="utf-8") as cf:
                    chat_data = json.load(cf)
                    if isinstance(chat_data, dict):
                        name_field = chat_data.get("name")
                        if name_field and name_field != "New Chat":
                            n = str(name_field)
                            actual_name = n if n.endswith(" (AutoPruned)") else f"{n} (AutoPruned)"
                        else:
                            first_msg = ""
                            agents = chat_data.get("agents", [])
                            if agents and len(agents) > 0:
                                history = agents[0].get("history", [])
                                if not history and "data" in agents[0]:
                                    history = agents[0]["data"].get("history", [])
                                for msg in history:
                                    if msg.get("role") == "user" and msg.get("content"):
                                        first_msg = msg.get("content")
                                        break
                            if first_msg:
                                n = first_msg.split('\n')[0][:50].strip()
                                if n:
                                    actual_name = f"{n}... (AutoPruned)"
            except Exception:
                pass
            
        data[chat_id] = {"archived_at": time.time(), "name": actual_name}
        tmp_path = str(plugin_json) + ".tmp"
        with open(tmp_path, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        os.replace(tmp_path, str(plugin_json))
        return True
    finally:
        if lock_fd is not None:
            try:
                import fcntl
                fcntl.flock(lock_fd, fcntl.LOCK_UN)
                os.close(lock_fd)
            except Exception:
                pass

def analyze_and_archive(chats_root: Path, plugin_json: Path, hot_days: int) -> tuple:
    now = dt.datetime.now(dt.timezone.utc)
    archived_count = 0
    total_scanned = 0
    
    if not chats_root.exists(): return 0, 0
    
    for p in chats_root.glob("*/chat.json"):
        total_scanned += 1
        age_days = get_true_age(p, now)
        
        if age_days > hot_days:
            chat_id = p.parent.name
            if archive_visually_in_plugin(plugin_json, chat_id, chats_root):
                archived_count += 1
                
    return total_scanned, archived_count

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--chats-root", default=str(DEFAULT_CHATS_ROOT))
    ap.add_argument("--plugin-json", default=str(DEFAULT_PLUGIN_ARCHIVE))
    ap.add_argument("--hot-days", type=int, default=DEFAULT_HOT_DAYS)
    args = ap.parse_args()
    
    scanned, archived = analyze_and_archive(Path(args.chats_root), Path(args.plugin_json), args.hot_days)
    print(f"Context Pruner Complete: Scanned {scanned} chats. Visually archived {archived} stale threads.")

if __name__ == "__main__":
    main()

Automating it

Once I saw it was safe, I tossed it into my cron jobs so I never have to think about it again. If you open your /a0/usr/crontab.save file, you can add this line at the bottom to make it sweep out old chats every hour:

# Context Pruner - Visually Archive Stale Chats
0 * * * * /usr/bin/python3 /a0/usr/scripts/context_pruner.py >> /tmp/pruner.log 2>&1

Hopefully, this helps out anyone else who has been struggling with mysterious UI lag after running the agent for a while! Your disk won't magically be emptied, but your browser will take a massive sigh of relief. Let me know if you guys have better ways of doing this, I'm always trying to learn.