vault-sync: 2026-09-13 12:07 (jimmy)

2026-09-13 12:07:23 -07:00
parent e918f23707
commit aa52eecb5c
50 changed files with 4101 additions and 103 deletions
@@ -0,0 +1,73 @@
+---
+type: research-summary
+source: "Julian Goldie (YouTube): OpenViking Cuts AI Agent Token Usage by 91%!"
+url: https://youtu.be/xhR5BQS0ZpI
+date_ingested: 2026-08-29
+tags: [ai-memory, byte-dance, openviking, agent-architecture]
+---
+
+OpenViking Cuts AI Agent Token Usage by 91%!
+by Julian Goldie (digital avatar) / YouTube
+https://youtu.be/xhR5BQS0ZpI
+
+=== TRANSCRIPT ===
+
+OpenViking cuts AI agent token usage by 91%.
+
+What if your AI agent is doing way more work than it needs to? Every single time it thinks, it rereads everything. Over and over, burning through text you never even see. Then ByteDance quietly dropped a free tool that stops it. 91% less load, same smarts, way less effort. Let me show you how OpenViking actually pulls that off.
+
+I'm the digital avatar of Julian Goldie, and my whole thing is helping you learn and actually use AI tools in your real work, not just watch a cool demo and forget it by lunch. So today, I'm breaking down what OpenViking is, how it cuts token usage this hard, what the real test numbers say, and three pro tips to get the most out of it. And stick with me, because the smartest way to use this is the part most people skip right past.
+
+So let's start simple. What even is OpenViking? It's a free, open source tool from ByteDance. Think of it as a memory system for AI agents. Right now, most AI agents have a bad memory problem. They forget what you told them. They ask for the same thing twice. They lose track of what worked yesterday. OpenViking fixes that.
+
+Instead of dumping all your info into one messy pile, it organizes everything like folders on a computer. Memories, documents, skills, all filed neatly in one place. The agent browses it like you browse files on your laptop.
+
+Here's how I'd use this for the AI Profit Boardroom. I take all our AI Profit Boardroom tutorials, the docs, the notes from past coaching calls, and let OpenViking file them into that neat memory system. Then when I ask an AI agent a question, it doesn't reread the whole stack. It knows exactly where to look. That gives me a helper for the AI Profit Boardroom that answers fast and doesn't get lost.
+
+Now, here's the clever part — and this is where that 91% comes from. When OpenViking saves something, it doesn't save it just one way. It saves it in three layers:
+
+Layer zero is a one-line summary, super tiny — around 100 tokens, just enough to say what this file is about.
+Layer one is a bigger overview, the key points — around 2,000 tokens.
+Layer two is the full thing, every single detail.
+
+Here's why that matters. Most old-school AI memory grabs everything at once — the full document, every time — even when the agent only needed one line. That's like reading a whole book to answer one tiny question. OpenViking doesn't do that. It reads the one-line summary first. If that's enough, it stops right there. If it needs more, it opens the overview. And only if it truly needs the deep detail does it open the full file. So the agent reads only as much as the job actually needs, nothing wasted.
+
+And it gets smarter than that. OpenViking doesn't just search blindly. It works like a sharp librarian. First, it figures out what you're really asking, then it finds the right folder, then it looks closer inside that folder. If there are folders inside folders, it keeps drilling down until it lands on the exact thing you need. So instead of one messy guess, you get a careful step-by-step search that actually finds the right answer.
+
+There are two more features I really want you to know about:
+
+First, you can actually see what the agent looked at. Most AI memory is a total black box — you have no idea why it grabbed the wrong thing. OpenViking shows you the trail: every folder it opened, every file it touched. So when something goes wrong, you can see why and fix it fast.
+
+Second, it learns as it goes. At the end of a session, OpenViking looks back at what happened, what worked, what the agent figured out, then it files that away as a fresh memory. So the more you use it, the smarter it gets.
+
+Okay, let's talk about that 91%, because I don't want you taking it on faith. ByteDance ran real tests on something called the LoCoMo benchmark. That's a test built for long conversations where the agent has to remember stuff from way back. They hooked OpenViking up to three different AI agents:
+
+- On one agent called OpenClaw, token usage dropped by 91% — and at the same time, its accuracy jumped from 24% all the way up to 82%.
+- On another agent, the drop was around 34%.
+- On Claude Code, about 63%.
+
+But every single one used fewer tokens and got more accurate. All three crossed 80% accuracy. That's the real story — not one lucky number, a real pattern across the board.
+
+So why does this actually matter to you? Two big reasons:
+
+First, speed — less to read means faster answers. In those tests, the agents responded up to 66% faster too.
+
+Second, reliability. An agent that remembers things and grabs the right context makes way fewer dumb mistakes. And if you're building anything real with AI, dumb mistakes are the thing that kills it.
+
+This is the kind of setup I'd run for the AI Profit Boardroom. Say I've got an agent helping answer AI Profit Boardroom member questions. Every time it helps someone, OpenViking pulls out what it learned and files it away. So the next member who asks something similar gets a sharper answer because the agent actually remembers what worked last time. It keeps getting better on its own without me touching it.
+
+And here's where AI is right now. Everyone is building agents — agents that write, agents that code, agents that answer questions all day long. But almost all of them slam into the same wall: memory. They forget, they waste effort, they eat up way more processing than they should. The big labs know this. And that's the exact problem OpenViking was built to solve. But instead of keeping it locked away, ByteDance made it free and open for everyone. That tells you where this whole space is heading. Memory is the next big fight in AI and OpenViking just moved the goalposts.
+
+So who actually needs this? If you're just chatting with an AI now and then, honestly, you don't need it. This is for people building agents that run over and over — support agents, research helpers, coding assistants, anything that has to remember stuff across lots of sessions. If your agent keeps forgetting, keeps repeating itself, keeps burning through huge piles of text, this is built for exactly you. And it plugs into tools you might already be using like Claude Code, Cursor, and Codex.
+
+All right, three quick pro tips before you go:
+
+Pro tip one: don't install anything yet. Go try OpenViking Studio first. It's a live demo that runs right in your browser over at OpenViking.ai. You can play with the whole thing, no setup at all, and see if it fits what you're doing before you commit.
+
+Pro tip two: use that retrieval trail I told you about. When your agent grabs the wrong thing, don't sit there guessing. Open up the trail, see which folder it walked into, and fix your setup from there. That one habit alone will save you hours.
+
+Pro tip three: check the license before you build something big on it. The main project uses AGPLv3. That's totally fine for a lot of uses, but if you're building a full product on top of it, read the terms first so there are no surprises down the road.
+
+That's OpenViking — a free tool that gives your AI agent a real memory and cuts the wasted effort by a massive chunk.
+
+=== END TRANSCRIPT ===
@@ -0,0 +1,84 @@
+#1 [github] open-kritt: Open-source, self-hosted AI vulnerability research tool that orchestrates agents to find and validat
+URL: https://github.com/Kritt-ai/open-kritt
+(1) It turns the manual bottleneck of security auditing into an automated agentic workflow, allowing builders to scale security without a massive team.
+
+(2) Stop manually hunting for bugs. open-kritt uses autonomous agents to find and validate vulnerabilities on your own infrastructure. It’s the shift from reactive patching to proactive, automated defense.
+
+
+#2 [github] nanocodex: Building blocks for frontier OpenAI agents in Rust. Nanocodex empowers you with Codex-level performa
+URL: https://github.com/gakonst/nanocodex
+(1) Rust is becoming the standard for production-grade agentic infrastructure where reliability and execution speed are non-negotiable.
+
+(2) Stop building your agents on bloated abstractions. Nanocodex provides high-performance, Rust-based primitives for frontier AI models. Move your production logic out of heavy wrappers and into optimized code.
+
+
+#3 [github] cindy: Consider it done. The open-source AI agent that works out of the box · 想到，就能做到。开源、开箱即用的 AI Agent。
+URL: https://github.com/makecindy/cindy
+1. It eliminates the "plumbing" hurdle that kills most indie projects before they reach MVP.
+
+2. Most AI agent projects die in the configuration phase. Cindy removes that friction with an out-of-the-box, open-source framework. Stop building infrastructure and start shipping features.
+
+
+#4 [github] pireel: The open-source alternative to Capcut、ChatCut. Drivable by any AI agent over MCP.
+URL: https://github.com/pireel/pireel
+(1) It turns manual video editing into a programmable pipeline for AI agents via MCP.
+
+(2) Video production is usually the final hurdle in creating autonomous social media machines. Pireel removes that barrier by exposing CapCut-style capabilities to LLMs through the Model Context Protocol. Build an automated content factory without the manual overhead.
+
+
+#5 [github] pinvou-agent: Open-source desktop AI agent for tools, files, knowledge, workflows, and real deliverables.
+URL: https://github.com/Pinvou/pinvou-agent
+1. It moves AI from a conversational wrapper to an execution layer by giving agents direct access to local files, tools, and workflows.
+
+2. Most AI projects are just chat wrappers. pinvou-agent shifts the focus to actual output by integrating tools and file systems directly into the desktop environment. It's an open-source foundation for building agents that do work instead of just talking about it.
+
+
+#6 [github] caspian-sdk: Agent communication SDK. The open-source agent communication layer for AI agents — email, WhatsApp, 
+URL: https://github.com/TryCaspian/caspian-sdk
+(1) It eliminates the "glue code" tax by abstracting fragmented messaging APIs into a single, unified layer for agent deployment.
+
+(2) Building AI agents shouldn't require mastering the unique quirks of every messaging API. Caspian-sdk provides a unified communication layer for WhatsApp, email, and beyond. Stop building wrappers and start building logic.
+
+
+#7 [github] memmy-agent: 🍙 A personal AI agent & local memory hub for all AI agents like Claude Code, Codex, OpenClaw and Her
+URL: https://github.com/MemTensor/memmy-agent
+1. It eliminates context fragmentation by providing a shared, persistent memory layer across disparate AI agents.
+
+2. Context fragmentation kills complex workflows. Memmy-agent solves this by creating a unified local memory hub for tools like Claude Code and Codex. Stop starting from scratch every time you switch agents.
+
+
+#8 [github] paritok-4b-v1: Non-destructive compression gateway for AI coding agents. Cuts token bills 25% on turn 1 to past 85%
+URL: https://github.com/Paritok-official/paritok-4b-v1
+(1) It eliminates the "context tax" of coding agents by slashing token costs without degrading model comprehension.
+
+(2) Coding agents are expensive because they re-send massive amounts of context with every turn. paritok-4b-v1 solves this by compressing the payload while keeping the logic intact. It cuts costs up to 85%—essential for anyone building scalable dev tools.
+
+
+#9 [github] andrej-karpathy-skills: Behavioral guardrails for Claude Code, distilled from Andrej Karpathy's field notes on where LLMs go
+URL: https://github.com/0xwilliamortiz/andrej-karpathy-skills
+1. Reliability is the bridge between a toy demo and a production-ready coding agent.
+
+2. Claude Code is powerful but requires strict behavioral constraints to be useful in production. These distilled notes from Karpathy provide the framework to turn erratic LLM outputs into disciplined engineering workflows. Stop guessing at prompts; start enforcing guardrails.
+
+
+#10 [github] deja-vu: Your agents already solved this. deja finds it — it indexes the sessions your coding agents already 
+URL: https://github.com/vshulcz/deja-vu
+1. Stop your agents from looping and wasting tokens by giving them a persistent memory of every past session.
+
+2. Most AI agents fail because they have no "memory" of previous turns. They get stuck in loops and waste context windows on tasks they've already attempted. Deja solves this by indexing your coding sessions so the agent actually knows what happened before it started.
+
+
+#11 [huggingface] QwQ-32B (text-generation) by Qwen
+URL: https://huggingface.co/Qwen/QwQ-32B
+**Why it matters:**
+QwQ-32B delivers "o1-style" reasoning in a footprint small enough to bypass the high costs and latency of frontier model APIs.
+
+**Social Post:**
+Stop overpaying for basic logic. QwQ-32B brings deep chain-of-thought reasoning to a 32B scale, making it a powerhouse for autonomous agents and complex coding tasks. It’s the ultimate middle ground between raw power and accessible deployment.
+
+
+#12 [github] open-kimi-ppt-skill: 非官方 Kimi Slides Skill：让 AI Agent 生成可编辑 PPTD + PPTX，并附带本地浏览器编辑器 Unofficial Kimi Slides skill for AI a
+URL: https://github.com/Binaryify/open-kimi-ppt-skill
+1. It solves the "last mile" problem by converting raw AI output into production-ready, editable slide decks instead of static text blocks.
+
+2. Stop wasting time copy-pasting LLM outputs into PowerPoint. This Kimi Slides skill bridges the gap between generation and production by creating actual .PPTX files with a local editor. A massive win for anyone building content automation tools.
@@ -0,0 +1,58 @@
+#1 [github] open-kritt: Open-source, self-hosted AI vulnerability research tool that orchestrates agents to find and validat
+URL: https://github.com/Kritt-ai/open-kritt
+[LLM error: <urlopen error timed out>]
+
+
+#2 [github] nanocodex: Building blocks for frontier OpenAI agents in Rust. Nanocodex empowers you with Codex-level performa
+URL: https://github.com/gakonst/nanocodex
+[LLM error: <urlopen error timed out>]
+
+
+#3 [github] cindy: Consider it done. The open-source AI agent that works out of the box · 想到，就能做到。开源、开箱即用的 AI Agent。
+URL: https://github.com/makecindy/cindy
+[LLM error: <urlopen error timed out>]
+
+
+#4 [github] pireel: The open-source alternative to Capcut、ChatCut. Drivable by any AI agent over MCP.
+URL: https://github.com/pireel/pireel
+[LLM error: <urlopen error timed out>]
+
+
+#5 [github] pinvou-agent: Open-source desktop AI agent for tools, files, knowledge, workflows, and real deliverables.
+URL: https://github.com/Pinvou/pinvou-agent
+[LLM error: <urlopen error timed out>]
+
+
+#6 [github] caspian-sdk: Agent communication SDK. The open-source agent communication layer for AI agents — email, WhatsApp, 
+URL: https://github.com/TryCaspian/caspian-sdk
+[LLM error: <urlopen error timed out>]
+
+
+#7 [github] memmy-agent: 🍙 A personal AI agent & local memory hub for all AI agents like Claude Code, Codex, OpenClaw and Her
+URL: https://github.com/MemTensor/memmy-agent
+[LLM error: <urlopen error timed out>]
+
+
+#8 [github] genoffice: Free, open-source AI office suite for macOS, Windows & Linux — Word (.docx), Excel (.xlsx), PowerPoi
+URL: https://github.com/genspark-ai/genoffice
+[LLM error: <urlopen error timed out>]
+
+
+#9 [github] paritok-4b-v1: Non-destructive compression gateway for AI coding agents. Cuts token bills 25% on turn 1 to past 85%
+URL: https://github.com/Paritok-official/paritok-4b-v1
+[LLM error: <urlopen error timed out>]
+
+
+#10 [github] andrej-karpathy-skills: Behavioral guardrails for Claude Code, distilled from Andrej Karpathy's field notes on where LLMs go
+URL: https://github.com/0xwilliamortiz/andrej-karpathy-skills
+[LLM error: <urlopen error timed out>]
+
+
+#11 [github] deja-vu: Your agents already solved this. deja finds it — it indexes the sessions your coding agents already 
+URL: https://github.com/vshulcz/deja-vu
+[LLM error: <urlopen error timed out>]
+
+
+#12 [huggingface] QwQ-32B (text-generation) by Qwen
+URL: https://huggingface.co/Qwen/QwQ-32B
+[LLM error: <urlopen error timed out>]
@@ -1,8 +1,8 @@
 # Athena Oracle — Status

-**Updated:** 2026-08-31  
-**Repo:** `~/Projects/athena-oracle/` (cloned from `Tony_tech/athena-oracle`)  
-**DB:** `~/Projects/athena-oracle/oracle.db`
+**Updated:** 2026-09-05  
+**Repo:** `~/athena-oracle-new/` (cloned from `Tony_tech/athena-oracle`)  
+**DB:** `~/athena-oracle-new/oracle.db`

 ## What it is

@@ -24,17 +24,18 @@ oracle/variants/ → Render config (default, research, devops, brief)
 |--------|--------|-------|
 | GitHub | ✅ Token-auth (5k req/hr) | 20 entries fetched, scored |
 | arXiv | ✅ Working | 20 entries fetched, scored |
-| Reddit | ⏸ 429 rate-limited | JSON blocked, RSS fallback also 429 from this IP |
+| Reddit | ✅ Working (RSS) | Subreddits: HuggingFace, llamacpp, artificial, DeepLearning. Rate-limit-aware (waits ~60s between subs) |
 | HackerNews | ✅ Working (via HN API) | 19 entries fetched, scored |
 | HuggingFace | ✅ Working | 20 entries fetched, scored |
 | RSS | ✅ Working | feedparser installed, 14 entries fetched |

 ## Current State

- **93 entries** in `oracle.db` (20 GitHub + 20 arXiv + 19 HN + 20 HF + 14 RSS)
- 82 scored via `attach_scoring()`
- **Verdicts:** 4 PUBLISH, 14 WATCH, 42 ARCHIVE, 33 DROP
- **Buckets:** 44 Uncategorized, 20 Research, 18 Infrastructure, 4 Shipping, 2 Culture, 2 Model Release, 3 Problem Solved
+- **144 entries** in `oracle.db`
+- 5 variants rendered: default, brief, devops, research, ai-news-daily
+- **Site deployed:** `https://preprod2.afterthedemo.com/` + `/ai-news-daily/index.html` + `/brief/` + `/devops/` + `/research/`
+- Deploy mechanism: pre-render locally → commit site/ → create Gitea release → webhook fires → listener syncs to VPS webroot
+- Build command set to `true` (no-op) since files are pre-rendered

 ## Done

@@ -44,6 +45,9 @@ oracle/variants/ → Render config (default, research, devops, brief)
 - `python -m oracle ingest --limit 20` — full pipeline working
 - Cron job `athena-ingest` (daily 24h) → ingests + scores + writes digest to vault
 - Vault project files created: `status.md`, `decisions.md`, `digest-template.md`
+- **2026-09-02:** Deployed to preprod2 — 5 variants live with fresh stories through 2026-09-02
+- **2026-09-02:** Fixed `cli.py` `_load_env` to tolerate missing `dotenv` module on VPS
+- **2026-09-05:** Reddit adapter working — AI subs (HuggingFace, llamacpp, artificial, DeepLearning), rate-limit-aware RSS. Two daily cron jobs (6am/6pm). Pushed `main` → live on preprod2. Workflow saved to `08_workflows/ai-news-daily-deploy.md`

 ## Not done / next

@@ -51,15 +55,17 @@ oracle/variants/ → Render config (default, research, devops, brief)
 - [ ] Fix Reddit RSS (429 from this IP — may need proxy)
 - [x] Cron job for daily ingestion
 - [ ] Wire digests into daily notes automatically
- [x] Test render (variants → static site) — 4 variants + AI News Daily built
+- [x] Test render (variants → static site) — 5 variants + AI News Daily built
 - [ ] Surface top entries to daily notes
+- [ ] Set up oracle pipeline on VPS (needs SSH access — currently blocked)

-## Deployment blocker (2026-08-31)
+## Deployment (2026-09-02)

- **Rendered fully locally** (99 entries, 31 summarized): 4 HTML variants in `_preview/{default,brief,devops,research}/` + `site/ai-news-daily/index.html` (12KB, 50 stories).
- **Deploy to `preprod1.afterthedemo.com` blocked:** all remote access is down. VPS SSH local-vps-reference:22 is firewalled (times out), Tailscale 100.64.0.1:22 times out, all users/key/password auth rejected. Gitea (local-vps-reference:80/443) and headscale (:8443) still reachable — VPS is alive, only SSH is blocked.
- **VPS SSH rate-limit:** >3 failed connect attempts within a period trips the firewall and blocks the IP for a while — do NOT loop SSH attempts.
- **Options (need Anthony):** (a) SSH in himself and add `~/.ollama/id_ed25519.pub` or `~/ssh-keys/vps-deploy.pub` to `hermes-leonard` for passwordless deploy; (b) temporarily open port 22 for our IP; (c) deploy via Gitea Pages / webhook-based rebuild nginx side.
+- **Deployed to `https://preprod2.afterthedemo.com/`** ✅
+- 5 variants live: default, brief, devops, research, ai-news-daily
+- Fresh stories through 2026-09-02
+- VPS SSH still blocked; pipeline lives locally for now
+- Oracle needs to be migrated to VPS (can't ingest from local PC without SSH)

 ## Decisions

@@ -67,3 +73,4 @@ oracle/variants/ → Render config (default, research, devops, brief)
 - Pure rule-based — no embeddings, no LLM classification
 - Velocity ranking for GitHub (not raw stars)
 - GitHub unauthenticated rate limit: 60 req/hr (budget calls, 30s timeout per source)
+- **VPS SSH is firewalled:** >3 failed connects blocks IP. Do NOT loop SSH attempts.