THIS IS F*CKING DANGEROUS
ex-SpaceXAI employee leaked a second-brain template for Grok Bot. 99% of Grok Bot users don’t know this setup exists
your documents, voice notes, research, and past decisions become connected memory. ask why you rejected an idea six months ago, and it retrieves the reasoning and sources. less repeated work, fewer wasted tokens, and answers grounded in what you already know
20 GitHub repos to recreate the setup:
01 Basic Memory → keep knowledge in readable Markdown files that an AI can search and update through MCP. your notes stay accessible outside the chat
https://t.co/CSUXMn7mf6
02 Cognee → turn documents and conversations into persistent knowledge graphs, connecting decisions to the discussions and evidence behind them
https://t.co/SAHO7NltPD
03 MemOS → add a memory layer that stores, retrieves, and manages information across tasks, with feedback for correcting what the system remembers
https://t.co/Z1v04sIuaK
04 Mem0 → retain useful preferences, facts, and interaction history so connected workflows can retrieve relevant memories in later sessions
https://t.co/iGhtPCz7jS
05 Graphiti → track relationships and how facts change over time, preserving the difference between what was true before and what is true now
https://t.co/G6lBZWAN10
06 LightRAG → combine graph relationships and vector retrieval to find connected information across documents, with support for incremental updates
https://t.co/hfyhBcbr7j
07 PageIndex → build a navigable tree of a long document so retrieval can find relevant sections with traceable page references
https://t.co/ErswLbyfZO
08 Karakeep → collect links, notes, images, and PDFs in a searchable library, with optional automatic tagging and summarization
https://t.co/EPsZIrI4ej
09 Linkwarden → preserve useful web pages as archived copies, keeping the source available even when the original link disappears
https://t.co/sFV98AM6KP
10 Paperless-ngx → turn scanned documents and paperwork into an organized, searchable archive that can feed your knowledge workflow
https://t.co/Q4gDUCWyV9
11 Unstructured → break documents into structured elements so your ingestion pipeline can separate useful content before indexing it
https://t.co/OuGpBRb2qV
12 MinerU → extract readable content from complex PDFs, scans, tables, and office documents, with references back to document locations
https://t.co/6G71QYPo70
13 whisper.cpp → transcribe recordings locally so spoken ideas and meeting discussions can become searchable text in your archive
https://t.co/Iaw2wMj05D
14 pgvector → store embeddings alongside your structured data in Postgres, then retrieve related passages with metadata and filters
https://t.co/4beLJw96qZ
15 sqlite-vec → add vector search to a lightweight SQLite database for a local memory store without a separate database server
https://t.co/uCivMCTJW2
16 Meilisearch → combine keyword and semantic search so your archive can find both an exact project name and a related idea
https://t.co/ibsGumnESl
17 Neo4j → store explicit connections between people, projects, sources, and decisions, then query how those pieces relate
https://t.co/wa1ZLUqpHX
18 watchfiles → detect changed files and trigger updates in your indexing scripts, keeping the archive current without repeatedly processing everything
https://t.co/0QUy4UgkDS
19 Syncthing → synchronize your knowledge files between computers so the notes you capture and the files your workflow reads stay aligned
https://t.co/JP8wodP5Ph
20 restic → create encrypted backups and recover previous snapshots when a bad edit or accidental deletion damages your knowledge collection
https://t.co/Zf9ZxB6lGb
start with one project and one memory backend. connect it to Grok Bot through supported MCP tools, APIs, or local scripts, then add the capture and retrieval pieces you need
test it with a question you already know the answer to: “why did we reject this approach?” a useful second brain should bring back the original reasoning, its evidence, and any later decision that replaced it
that’s when an old conversation becomes something you can build on months later
save this. the work you’ve already done should keep paying you back
the article below shows how to reuse that knowledge without loading your entire archive into every Grok Bot conversation ↓
Bambu Lab R1, the CO₂ laser built with the same motion control as our printers.
Every cut lands where it should.
The specs you've been asked about:
• 55W CO₂ Laser - cuts up to 20mm single-pass cutting
• 600 × 300 mm bed, 3m throughput with conveyor
• 1000 mm/s max speed without losing detail
• Auto laser alignment, first for a CO₂ laser cutter
• Cameras, lasers and encoders work as one, within 0.2mm positioning accuracy
Big job. Light work.
Explore R1 https://t.co/1S13tO2TWj
THIS IS A REAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code
The idea: run Sonnet 5.5, Haiku 5.5 and Opus 5.5 together, each one doing only the job it's best at
Better output and way fewer tokens: every task lands on the right model
You just start Claude Code like this:
CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet
here's how it splits:
→ Sonnet 5.5 runs the main session, writes the code and applies the fixes
→ Haiku 5.5 swarms the repo in parallel: search, grep, docs and test audits, each in its own context
→ Opus 5.5 sits in its own architect subagent for the big decisions and signs off on the diff
→ you stop burning Opus on routine work and stop flooding the main session with raw logs
Opus only steps in at three moments:
→ before a plan locks
→ when the same error hits twice
→ before calling it done (signing off on the git diff)
Sonnet builds, Haiku swarms, Opus reviews
JEV engineering is the same move one layer down: the forks that need no thinker (which agent, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split
the full tree
> Sonnet 5.5 runs the main session and writes the code
> search maps the repo on Haiku 5.5 (read-only)
> grep finds call sites on Haiku 5.5 (own context, only the summary comes back)
> audit checks diffs on Haiku 5.5 in a temporary worktree (isolation: worktree)
> architect runs on Opus 5.5 (its model: opus beats the haiku default), reviews the final diff
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Reconfigure my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 and set CLAUDE_CODE_SUBAGENT_MODEL=haiku
2. Create four subagents in .claude/agents/: search (maps the repo), grep (finds call sites) and audit (checks diffs) on Haiku 5.5, plus architect with model: opus
3. Set isolation: worktree on audit so it never touches my working branch
4. Add one rule to CLAUDE.md: send every repo search and test run to a Haiku 5.5 subagent, and call architect before a plan locks, after the same error twice and before done
5. Route fast deterministic forks (tool choice, path selection, retries) through JEV
Show me every change as a diff first. No edits until I say go"
↳ https://t.co/neE4NaJaVj
save it, you'll need it