curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/v2.2.0/install.sh | bash

For a single agent you can also run the appropriate plugin command (Claude Code, Gemini CLI, etc.) – see the README for the exact syntax.

Once installed, run caveman learn to see where your tokens leak, then let the tool guide you through safe, consent‑gated fixes.

---

Technical highlights

* Per‑type compressors – JSON (70‑90 % reduction), logs (85‑95 %), code (40‑70 %), diffs (60‑80 %), search results (80‑95 %), generic text/HTML (50‑80 %).
* Tree‑sitter integration (Go, Python, JS/TS) for structural code compression; pure‑Go fallback for Go‑only environments.
* BM25‑based relevance ranking combined with recency and error signals to pack the most useful context into the model’s token budget while preserving chronological order.
* Content‑addressed “CCR” store guarantees byte‑exact recovery; every transformation is logged with a clear “decline reason” when it would enlarge the payload.
* The proxy is a BSL‑1.1 runtime with an MIT‑licensed CLI – you can compile it yourself from source (Go + pnpm) if you prefer not to use the signed binaries.
* Benchmarks (Claude Code, 54 runs) show a 33.2 % reduction in input tokens and unchanged answer correctness; pixel mode on a 63.7 k‑char JSON+log slab drops estimated tokens from ~55 k to ~11 k.

---

Who should care?

* Prompt engineers looking to squeeze more mileage out of token‑priced models.
* Dev teams that run continuous LLM‑assisted coding, CI, or debugging pipelines and see their bills balloon.
* Open‑source AI hobbyists using Claude, Gemini, Codex, or any of the 30+ supported agents.
* Anyone who wants to keep the “brain” of their AI big while making the “mouth” tiny.

---

Takeaway – Talk less, think more: Caveman lets your agents stay smart without swallowing the token bill.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

📌 Spotted on GitHub Trending: makeplane/plane — let's break it down.

🔗 https://github.com/makeplane/plane
📝 🔥🔥🔥 Open-source Jira, Linear, Monday, and ClickUp alternative. Plane is a modern project management platform to manage tasks, sprints, docs, and triage.
──────────────────────────────

Plane – Modern, open‑source project management

What’s it for?
Plane is a self‑hostable (or cloud‑hosted) tool that lets teams track issues, run cycles (formerly sprints), organise roadmaps and keep all the project data in one tidy place – without the endless admin overhead that comes with many “all‑in‑one” solutions.

Key features at a glance

Work Items – Rich‑text task editor, file uploads, sub‑properties and cross‑issue linking.
Cycles – Visual burn‑down charts and progress tracking to keep momentum.
Modules – Break huge projects into bite‑size, manageable chunks.
Views – Build custom filters, save them, and share with teammates.
Pages – AI‑enhanced note‑taking with a full‑featured editor; turn notes into actionable items in a click.
Analytics – Real‑time dashboards that surface trends, blockers and health metrics.


How to get started

1. Plane Cloud (quick‑start) – Sign up at app.plane.so and you’re ready to go, no servers to manage.

2. Self‑hosted – Pick the deployment style that matches your ops stack.

# Docker‑Compose (most common)
git clone https://github.com/makeplane/plane.git
cd plane
docker compose up -d

For Kubernetes, follow the official guide (link in the repo). Managed‑hosting options like Zenith are also listed.

Instance administration – Once up, admins can dive into “God mode” to tweak instance‑wide settings, data retention policies, SSO, etc.

Technical highlights


Frontend – Built with React Router, delivering a fast, SPA‑like experience.
Backend – Powered by Django, handling complex relational data and permissions.
Node.js – Supports the build pipeline and real‑time features.
Rich‑text editing, file storage, and AI integrations are all open‑source, making extensions straightforward.


Who should care?


Product managers and scrum masters who need a lightweight yet powerful issue tracker.
Engineering teams that want full control over data (self‑host) or a hassle‑free SaaS option.
Open‑source enthusiasts looking to contribute to a modern Django + React stack.
Start‑ups and small businesses that can’t afford pricey PM tools but still want analytics and custom views.


Community & contribution – Plane thrives on feedback via its forum, GitHub Discussions, and the issue tracker. Documentation is split into product (how‑to) and developer (API, self‑hosting) sections. Security reports go to security@plane.so. The project is GPL‑3.0‑AGPL licensed, encouraging both use and contribution.

Takeaway – Plane gives you the power of a full‑featured PM suite without locking you into a vendor, letting you focus on building, not on tool‑maintenance.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe

🔍 Deep-diving into Tencent/AI-Infra-Guard — fresh off the trending list.

🔗 https://github.com/Tencent/AI-Infra-Guard
📝 A full-stack AI Red Teaming platform securing AI ecosystems via Agent Scan, Skills Scan, MCP scan, AI Infra scan and LLM jailbreak evaluation.
──────────────────────────────

What is AI‑Infra‑Guard (A.I.G)?
A.I.G is Tencent Zhuque Lab’s all‑in‑one AI red‑team platform. It bundles security scanners for AI models, AI‑agent skills, model‑centered components (MCP) and jailbreak evaluation, plus a marketplace for vetted security skills. In short, it lets you stress‑test your AI stack from code to deployment with a single, user‑friendly interface.

Key Features

🔎 Skill‑Scan Engine – Detects nine categories of skill‑level risks (instruction hijacking, memory poisoning, code execution, privilege escalation, tool hijacking, insecure dependencies, etc.) and scores on the public SkillTrustBench leaderboard (top F1 0.9848 with Claude Opus 4.6).

🛡️ ClawScan (OpenClaw Security Scan) – One‑click audit of OpenClaw configurations, skill vulnerabilities, CVE exposures and privacy leaks.

🤖 Agent‑Scan – Automated multi‑agent framework that checks agent‑side skills, web‑exfiltration, OWASP‑style issues and more.

🧩 MCP‑Scan – Scans model‑centered components for tool poisoning, credential exfiltration, command injection and dozens of LLaMA cpp CVEs.

🚪 Jailbreak Evaluation – Runs multi‑turn jailbreak attacks (Many‑Shot, PAIR, GOAT, ActorAttack) to gauge model resistance.

🛒 AI Security Skill Market – Official marketplace where you can publish or acquire security‑hardened skills; the frontend is fully open‑sourced.

⚙️ Stand‑alone CLI Tools – aig-skill-scan, aig-agent-scan, aig-mcp-scan can be run independently or embedded into CI/CD pipelines.

📊 API‑Checker & Model Relay – Unified service that lists available LLM endpoints and validates request/response formats.

How to Get Started

🐳 Docker (quickest)

git clone https://github.com/Tencent/AI-Infra-Guard.git
cd AI-Infra-Guard
docker-compose -f docker-compose.images.yml up -d

Open a browser at http://localhost:8088 to reach the web UI.

🚀 One‑Click Install Script (installs Docker if needed)

curl https://raw.githubusercontent.com/Tencent/AI-Infra-Guard/refs/heads/main/docker.sh | bash

🛠️ Python CLI for Skill Scan

pip install aig-skill-scan
export LLM_API_KEY="your-api-key"
aig-skill-scan --repo /path/to/skill \
               -m deepseek-v4-flash \
               --language en \
               -o result.json

🔧 Build from Source – Clone the repo, then run docker-compose up -d (or build the Go CLI with go build -o ai-infra-guard ./cmd/cli/main.go) for full control.

Technical Highlights

- Performance‑focused: Skill‑scan runs in parallel across LLM backends, achieving sub‑second latency on typical models.
- Extensible rule base: > 2000 CVE rules, continuously updated; users can add custom policies via simple YAML.
- Multi‑mode MCP scanning: Dynamic mode enforces tool whitelisting to block RCE attempts.
- Zero‑trust deployment: Designed for internal enterprise use; no public auth layer, so keep it behind a firewall.
- Cross‑language support: Scanners accept Python, JavaScript, and compiled bytecode (.pyc) with bypass detection.

Who Should Use It?
(1/2)

🚀 Meet RyanCodrai/turbovec: a gem from today's GitHub trending list.

🔗 https://github.com/RyanCodrai/turbovec
📝 A vector index built on TurboQuant, written in Rust with Python bindings
──────────────────────────────

What is turbovec?
is a fast, memory‑efficient vector search library written in Rust with Python bindings. It implements Google Research’s TurboQuant algorithm – a data‑oblivious quantizer that needs no separate training phase and delivers near‑optimal distortion.

Why you’ll care
- A 10 M‑document float‑32 corpus (~31 GB) fits in ~4 GB of RAM.
- Search is consistently faster than FAISS IndexPQFastScan (≈3.4× speed‑up at 4‑bit, ≈20‑30 % at 2‑bit).
- No “train‑then‑load” step – you can add vectors on the fly.
- Incremental, crash‑safe persistence (`sync`) writes only what changed.
- Built‑in filtering lets you restrict searches to an allow‑list without extra post‑processing.
- Pure‑local deployment – perfect for privacy‑sensitive or latency‑critical RAG pipelines.

Key features at a glance
- Online ingest: `add()` vectors anytime; no rebuilding.
- SIMD‑optimized search: hand‑written kernels (NEON SDOT/SMMLA, AVX‑512 VNNI, AVX2, scalar fallback).
- Incremental saves: `sync(path)` persists deltas with a single fsync; full snapshots still available via `write`/`load`.
- Filter‑aware search: pass an id allowlist or slot bitmask; the kernel skips irrelevant blocks.
- Stable external IDs: `IdMapIndex` keeps your own uint64 identifiers and supports O(1) deletes.
- Framework adapters: drop‑in replacements for LangChain, LlamaIndex, Haystack, Agno.

Getting started – Python

pip install turbovec

from turbovec import TurboQuantIndex

# create a 1536‑dim index, 4‑bit quantization
index = TurboQuantIndex(dim=1536, bit_width=4)

# add vectors (numpy float32, shape (n, dim))
index.add(vectors)
index.add(more_vectors)

# search
scores, ids = index.search(query, k=10)

# persistence
index.write("my_index.tv")          # full snapshot
index.sync("my_index.tv")           # incremental, crash‑safe
loaded = TurboQuantIndex.load("my_index.tv")

Stable IDs example

from turbovec import IdMapIndex
import numpy as np

idx = IdMapIndex(dim=1536, bit_width=4)
idx.add_with_ids(vectors, np.array([1001, 1002, 1003], dtype=np.uint64))

scores, external_ids = idx.search(query, k=10)
idx.remove(1002)                     # O(1) delete by id
idx.sync("my_index.tvim")

Hybrid (filtered) search – combine a coarse external retriever with dense reranking:

allowed = np.array(db.execute(
    "SELECT id FROM docs WHERE tenant=?", (t,)
).fetchall(), dtype=np.uint64)

scores, ids = idx.search(query, k=10, allowlist=allowed)

The filter is evaluated inside the SIMD kernel, so only the allowed blocks incur any computation.

Getting started – Rust

cargo add turbovec

use turbovec::TurboQuantIndex;

let mut index = TurboQuantIndex::new(1536, 4).unwrap();
index.add(&vectors);
let (scores, ids) = index.search(&queries, 10);
index.write("index.tv").unwrap();
let loaded = TurboQuantIndex::load("index.tv").unwrap();

(1/2)

Technical highlights
- TurboQuant provides data‑oblivious quantization with near‑optimal distortion and no training overhead.
- SIMD kernels operate on a vector‑major layout, allowing direct dot‑product computation without costly transposes.
- On ARM, kernels use NEON SDOT/SMMLA; on x86 they leverage AVX‑512 VNNI and `vpermb`.
- Benchmarks (100 K vectors, 1 K queries, k = 64) show median single‑thread speeds 3.4× faster than FAISS at 4‑bit and 20‑30 % faster at 2‑bit across both architectures.
- Insertion latency per vector is 6‑20 µs (≈8‑14× faster than FAISS), and deletions are O(1) at sub‑microsecond cost.
- Compression plots demonstrate up to 8× reduction in RAM vs raw float32.

Who should use turbovec?
- Engineers building Retrieval‑Augmented Generation (RAG) systems where memory, latency, or data‑privacy are critical.
- Teams that need a drop‑in FAISS alternative but want better speed and smaller footprints.
- Rust or Python developers who prefer a single‑library solution with native SIMD performance.
- Anyone integrating vector stores into LangChain, LlamaIndex, Haystack, or custom pipelines.

One‑liner takeaway
lets you store massive embedding collections in a few gigabytes and search them faster than FAISS – all while staying completely local.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)