pardonmeibeenactinglilpoor retweeted
Claude Code on desktop now works with the iOS simulator.
Build and run your iOS app, and the simulator opens in a panel right next to your conversation. Available today in public beta.
pardonmeibeenactinglilpoor retweeted
Introducing GPT-Red
An internal automated red teamer on a mission to find our models’ prompt injection vulnerabilities at scale, helping us build stronger defenses before wider deployment.
openai.com/index/unlocking-s…
pardonmeibeenactinglilpoor retweeted
How to use both Claude Fable 5 and GPT-5.6 all day without hitting limits.
Most people don't know you can run both inside the same session.
Fable 5 as the orchestrator. GPT-5.6 as the executor. 10 subagents working in parallel.
This setup saves at least 60% of your Fable 5 token consumption — and you never hit the 5-hour limit again.
You only need to set it up once. Here's exactly how:
━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 1 — Install the Codex plugin inside Claude Code
Run these three commands:
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 2 — Tell Fable 5 to finish the setup
Paste this prompt into Claude Code:
"Set up Codex inside this Claude Code environment. Use the official OpenAI Codex plugin that was just installed. Run /codex:setup. If Codex CLI is missing, install it. If Codex is installed but not authenticated, ask me to authenticate with my ChatGPT account. After auth is complete, verify that Codex works from inside Claude Code. Then confirm that the codex:codex-rescue sub-agent is available. Do not change any project code during setup."
━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 3 — Authenticate once
Fable 5 will trigger the Codex setup automatically.
You authenticate your ChatGPT or Codex account once.
After that, Codex runs from inside Claude Code using your existing Codex subscription — no extra cost, no extra setup.
━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 4 — Tell Fable 5 how to delegate work
Paste this prompt:
"From now on, use this workflow:
You are the orchestrator.
Use Fable 5 for planning, repo understanding, architecture decisions, task decomposition, and final review.
Use codex-rescue as the executor when a task needs heavy implementation, debugging, test fixing, refactoring, or multi-file code edits.
When delegating to Codex, use /codex:rescue.
Prefer GPT-5.6 Sol medium as the daily driver for implementation tasks.
Keep Codex tasks focused and specific.
After Codex finishes, inspect the result yourself before accepting it.
Do not blindly trust Codex output."
━━━━━━━━━━━━━━━━━━━━━━━━━━
WHICH GPT-5.6 MODEL TO USE AND WHEN
This is where most people leave money on the table. Not all GPT-5.6 tiers are equal.
GPT-5.6 Sol medium → your daily driver
DeepSWE score: 61. Cost: $1.86. Fewer steps than almost every other model on the benchmark. This is the model doing 80% of the execution work in this setup. Fast, cheap, accurate enough for most implementation tasks.
GPT-5.6 Sol extra high → planning and orchestration
DeepSWE score: 71. Cost: $4.70. Use this when the task needs serious reasoning — architecture decisions, task decomposition, complex debugging. Scores higher than Fable 5 extra high (70) at less than a third of the cost ($13.41 vs $4.70). This is the model that replaced Fable 5 as my planning layer.
GPT-5.6 Terra/Luna → pure execution
Fast. Cheap. No overthinking. Once the plan is locked, this is what runs it. Extremely fast execution, minimal bugs, high quality output on well-defined tasks.
━━━━━━━━━━━━━━━━━━━━━━━━━━
THE ULTIMATE PLAN: 3-MODEL WORKFLOW
If you want maximum output quality at minimum cost, this is the setup:
Step 1 → Plan with GPT-5.6 Sol extra high
Full task/session/project planning. Architecture. Decomposition. Edge cases.
Step 2 → Critique with Fable 5 high
Find loopholes. Patch loose ends. Challenge assumptions. Fable 5 is at its best here — pure reasoning, no implementation cost.
Step 3 → Execute with GPT-5.6 Terra/Luna
Implement the battle-tested plan. Fast, clean, no waste.
TLDR:
Plan → GPT-5.6 extra high
Critique → Fable 5 high
Execute → GPT-5.6 Terra/Luna
The orchestrator thinks. The critic patches. The executor builds. You review.
━━━━━━━━━━━━━━━━━━━━━━━━━━
4 PRO TIPS TO NEVER HIT A LIMIT AGAIN
→ Tip 1: Turn this into a skill
Name it Fable-GPT. Call it at the start of every session. One command activates the entire workflow — no re-pasting prompts every time.
→ Tip 2: Use skill + goal for heavy tasks
Goals are best for long-horizon work. Set the goal, activate the skill, let the orchestrator-executor loop run until it's done. Check back when it surfaces for review.
→ Tip 3: Use subagents if you're on the Codex 20x Pro plan
Run 5 to 7 parallel subagents at once. With this setup, you will never hit the 5-hour limit. Each agent works independently on its assigned task while the others run in parallel.
→ Tip 4: Clear context after 4 compactions
Context rot is real. After 4 /compact cycles the conversation quality degrades. Use a /handoff skill before clearing to preserve the critical context — task state, decisions made, what's left to do. Start the new session by loading the handoff file.
━━━━━━━━━━━━━━━━━━━━━━━━━━
THE FULL PICTURE
Before this setup:
→ Fable 5 hits limits by midday
→ Heavy implementation burns your best tokens
→ You manually switch between tools
→ One model, one pace, one bill
After this setup:
→ GPT-5.6 Sol medium handles 80% of execution at $1.86/task
→ GPT-5.6 extra high outplans Fable 5 at 3x lower cost
→ 3-model critique loop catches every bug before it ships
→ 5 to 7 parallel subagents running simultaneously
→ 60%+ fewer Fable 5 tokens consumed
→ Never hit the 5-hour limit again
One setup. Runs forever.
Save this. Set it up tonight.
pardonmeibeenactinglilpoor retweeted
A friend of mine matched with guy on Tinder.
They scheduled a date on the 14th.
The guy just canceled it so that he can spend more time with Fable 5 right after this announcement.
pardonmeibeenactinglilpoor retweeted
Average Codex users:
> keeps getting rate-limit resets
> gets 10% more usage
> 5-hour cap temporarily disappears
> codex keeps working until the task is finished
> Sleeps peacefully
Average Claude Code users:
> Watches the weekly limit disappear in real time
> Hits the cap halfway through the task
> Claude stops immediately
> Begs Anthropic for another rate-limit reset
> Anthropic announces another “final” extension
> Starts panic-coding before access disappears again > Ends up in the hospital
pardonmeibeenactinglilpoor retweeted
China has killed the entire vector database industry.
They open-sourced TencentDB Agent Memory. It gives any AI agent long-term memory that runs 100% locally.
No Pinecone. No cloud APIs. No repeating yourself every session.
- 61% fewer tokens
- PersonaMem accuracy: 48% → 76%
- Zero external API dependencies
- Runs on plain SQLite
Most memory systems compress your history into an opaque vector pile. when recall goes wrong, you're guessing. this one doesn't compress, it builds a semantic pyramid.
L0 Conversation → L1 Atom → L2 Scenario → L3 Persona.
Short-term state gets encoded as a Mermaid graph in your agent's context. verbose tool logs get offloaded to disk. when the agent needs proof, it drills back via node_id to the exact raw log.
no lossy compression. every layer is readable markdown you can just open and inspect.
5.1k stars. 100% Open Source.
pardonmeibeenactinglilpoor retweeted
WEB SCRAPING JUST GOT A SERIOUS UPGRADE.
PixelRAG doesn't read HTML. It reads the page exactly like you do.
100% open-source.
Instead of parsing websites into plain text, it captures screenshots and lets a vision model retrieve answers directly from the pixels.
Why that's a big deal:
• HTML parsers silently lose information.
• Tables, charts, formulas, and layouts often disappear.
• Even changing the parser can swing RAG accuracy by ~10%.
PixelRAG skips that entire bottleneck.
It indexes what users actually see.
The team built a visual index of 30M+ Wikipedia screenshots, and it outperformed the strongest text-based RAG baseline by 18.1% on text-only QA.
Even cooler:
It includes a Claude Code plugin that gives Claude visual browsing.
Instead of scraping the DOM, Claude can screenshot any webpage, PDF, arXiv paper, or even your local app—and answer based on the rendered page.
The pipeline is surprisingly clean:
→ Render pages into image tiles
→ Embed with Qwen3-VL-Embedding (LoRA-tuned on screenshots)
→ Store in a FAISS index
→ Search visually
The best part?
Upgrade to a better vision model later, and you don't need to rebuild the index.
Because the index stores pixels, not parsed text.
Fully open-source under Apache 2.0.
GitHub: github.com/StarTrail-org/Pix…