AI安全最讽刺的一幕:OpenAI的agent监控曾只在agent交还控制权时触发——agent只要一直不停手,就能一直躲开审查。
METR和Redwood驻场三周,还挖出两个能直接关掉新agent监控的请求头。
OpenAI说已修复,METR说没验证。
自己审自己,靠的是信用,不是工程。
metr.org/blog/2026-10-22-red…
Alpha Desk is live 🚀
Giving an AI agent market data is easy now. Plug in a data MCP, add a few skills, and it can "do research".
But that agent only got a pair of eyes. The numbers in its report are still whatever the model says they are. It forgets everything when the chat ends. And when people call it "self-improving", it usually means the model rewrote its own prompt because it felt better about it.
I spent 4 years building big data and agent observability systems at a large internet company. Alpha Desk is what I think an AI research desk should actually look like.
It's a preconfigured A-share research workspace for DeepSeek Harness: 9 finance bots, 35 research skills and 6 report types, ready out of the box.
📊 Numbers come from code, not from the model
The report engine runs fetch, compute, render, then independent review. The bot that writes a report never reviews it. Every number in the final report traces back to the data and the calculation that produced it.
🧠 Research compounds instead of resetting
Deep memory records what each bot concluded, why, and how it turned out, so cause and outcome stay linked. A shared team knowledge base keeps all 9 bots working from the same facts, with independent review and source drift detection when an upstream source changes.
👥 A team, not a do-everything assistant
9 bots with clear roles, 35 skills and 6 report types (technical comparison, stock snapshot, event note, earnings review, sector comparison and deep-dive), already wired together, so you don't have to design the workflow or write the prompts yourself.
🧬 Agent self-evolution (RSI, in development)
This isn't a skill that edits its own prompt. RSI evolves the whole 9-bot team, and every change has to earn its place:
Bots rerun on frozen data snapshots, so results are comparable.
Scoring has three layers: outcome 40%, process 45%, cost 15%.
Each experiment changes exactly one file, as a single-variable A/B test.
A change is promoted only with n ≥ 10 and the lower bound of the 95% confidence interval above zero.
A human reviews and merges it. Nothing merges itself, and every change can be rolled back.
Most "self-improving" agents just tell you they got better. Ours have to prove it with experiments, then get a human sign-off.
Early access is open now 👉 deepseek-alpha.com
Research only. Not investment advice.
Built Alpha Desk on @Fei2411's DS Bot: one install, a 9-bot A-share research team.
Chief sets up the team. Chan theory overlays on the chart, and agents only mark levels they can back with data. Price alerts wake a specific bot. No buy/sell calls.
causal-memory.com
Your agent forgets why it decided.
After 5 compactions, text memory recalled only ~45% of the key decisions that mattered. The causal table: 100%.
So I built causal-memory — decision → outcome edges in SQLite, outside the context window, and a warning before it repeats a blocked mistake.
30 seconds, sound on 🔊
🤖 Made with AI
I'm a software engineer based in China, with 4 years at a major internet company working on big data and agent observability. 🇨🇳
Now building in the open: causal-memory (agent memory with a causal core, in Rust), quant multi-agent systems + MCP.
Looking to connect with:
• Solo founders
• Software engineers
• Indie hackers
• AI / agent builders
• Product builders
• People building cool stuff
Open to remote work and interesting collaborations.
Let's connect, learn, and build together. 🤝
Built in Rust, with MCP (stdio + HTTP) and hybrid BM25 + semantic retrieval.
Code and the compaction experiment are here: github.com/JingxuanC/causal-…
Most agent memory systems only remember what happened.
I built causal-memory to also remember what *didn't* — the bad action that was blocked, and why.
Those inhibitory edges (a decision → the outcome it prevented) are often the most valuable lesson of all. Without them, an agent will happily repeat a mistake it once narrowly avoided.
Building it in Rust, memory with a causal core that lives outside the context window: github.com/JingxuanC/causal-…
