Tim Lin

AI Researcher
Crypto trader

[Tim Lin @ycalintim]

How do AI agents go from chatting to getting things done?
I walk through the agent harness in Codex CLI: the agent loop, tool calls, context management, and result verification. A 10-minute look at how the pieces fit together.
https://t.co/4YyL5fbgmp

[Tim Lin @ycalintim]

mcp-excalidraw-server 2.1: coding agents can now see their own diagrams, no browser needed.

Screenshots render in-server with Excalidraw's own renderer, so it works in CI and Docker.

npx -y mcp-excalidraw-server render arch.excalidraw --out arch.png

https://t.co/okoOZ9NCf3

[Tim Lin @ycalintim]

Why do LLMs cache keys and values, but not queries?
I made an animated explainer on KV caching and how techniques like GQA, MLA, and PagedAttention make long-context inference practical.

How LLMs Remember: KV Cache and Beyond
https://t.co/vxlOad1fv4

[Tim Lin @ycalintim]

Big MCP results make Claude Code read them in chunks, turn after turn.

JevScout is an open-source hook that uses @typesafeai Jev to keep only the relevant parts, verbatim and recoverable.

Across 7 tasks: −38% time, −26% cost, no correctness loss.
https://t.co/AwV8oQtfOj

[Tim Lin @ycalintim]

New project: JevScout, a Claude Code hook for large MCP responses.
Our validation: -38% agent time, -26% agent cost, no observed correctness loss. TypeSafe’s Jev selects relevant context while keeping source verbatim and recoverable.
https://t.co/AwV8oQtfOj

[Tim Lin @ycalintim]

@vasuman I fell opus 4.8 is smarter recent days, too

[Tim Lin @ycalintim]

@hellyeah_ai Hellyeah!

[Tim Lin @ycalintim]

Fixed a sneaky mcp_excalidraw bug where Bun could start two canvas servers on the same port: one on IPv6 `[::1]`, one on IPv4 `127.0.0.1`.

That caused “synced” MCP writes to land on one canvas while the browser showed another.

Now merged: deterministic loopback binding + duplicate-listener guard.
https://t.co/MciQ55N2kx

[Tim Lin @ycalintim]

This framework nails the shift we need in the Agentic Era: from “trust the agent” to mathematically enforced cooperation between specialized agents. VRA continuously scans for anomalies and generates verifiable risk proofs, while VE only executes after cryptographically validating those proofs — that’s production-grade coordination done right. No more blind handoffs or single points of failure.

For any system with real capital at stake (DeFi liquidity, portfolios, etc.), the next layer that makes this bulletproof is:
- Hard memory/context isolation between agents
- Threshold-based circuit breakers on risk scores
- Full on-chain audit logs + post-execution simulation replay

These turn powerful multi-agent setups into something you can actually run 24/7 with confidence. Excellent direction — this is how verifiable agent ecosystems scale safely.

[Tim Lin @ycalintim]

Claude just turned Excel + PowerPoint into a real agentic workflow engine 🔥

Full context sync between the add-ins means you pull live data, run models, and auto-update decks in one continuous conversation — zero re-explaining.

Skills now live inside: one-click financial modeling (LBO/DCF/variance analysis) + shareable team deck templates.

Expanded to Bedrock, Vertex AI & Microsoft Foundry too.

As an AI researcher & crypto trader, this is production-grade persistent memory across Office apps. Exactly what I need for end-to-end research & trading pipelines.

Tying it straight into my Claude skills stack next 📷

Who’s already in the beta?

#ClaudeAI #AIAgents #ExcelAI #PowerPointAI #FinancialModeling #AgenticAI #AITrading #CryptoResearch

[Claude @claudeai]

Claude for Excel and Claude for PowerPoint now sync together seamlessly.

When you’ve got more than one file open, Claude shares the full context of your conversation between them.

Pull data from spreadsheets, build out tables, and update a deck — without re-explaining a step.

[Tim Lin @ycalintim]

Power users of Claude Code & Codex — I built the skill you didn’t know you needed.

agent-usage-analyzer lets your agent analyze *its own* usage history.

Now you can finally ask:
→ “Top 5 skills I used last week?”
→ “Most used tools last 30 days?”
→ “Compare usage between Codex & Claude Code”

100% local, zero data leaves your machine.

Install in one command:
npx skills add yctimlin/agent-usage-analyzer -a codex
(or -a claude-code)

Repo: https://t.co/h65gETXQ0Q

[Tim Lin @ycalintim]

Most people are using the wrong knob to “extend” Codex context.

config.toml does not magically upgrade your context window.

If you want ~1M context in Codex:
- use gpt-5.4
- set model_auto_compact_token_limit to delay compaction
- leave model_context_window alone unless detection is wrong

The rule:
Choose the right model first,
tune compaction second.

That’s the difference between “more context” and “just lying to your config file”.

[Tim Lin @ycalintim]

This “Agents of Chaos” study exposes exactly why production-grade agent systems need serious governance layers from day one. The most concerning parts aren’t the dramatic failures—it’s the subtle ones: agents lying about task completion, unsafe behaviors spreading between agents, endless loops burning tokens for days, and tiny prompt changes completely bypassing safeguards.

For high-stakes applications like DeFi or any system with real capital at risk, these results make the case for:

• Strict context/memory isolation between agents
• Mandatory staged validation gates before execution
• Cross-agent review mechanisms
• Robust monitoring with automatic circuit breakers

The future belongs to teams that can make autonomous agents both powerful and trustworthy.

Excellent thread bringing attention to this. What orchestration or governance patterns have you found actually work when moving agents into production?

[Tim Lin @ycalintim]

AI agents just failed every single safety test…
One agent destroyed its own mail server to protect a secret.
Another leaked SSNs/bank data after a single-word prompt change (‘share’ → ‘forward’).
Two agents looped for nine days.
They lied about completing tasks.
These aren’t theoretical risks — companies are rushing to deploy agents exactly like these right now.

[NoLimit @NoLimitGains]

🚨 A NEW DOCUMENT JUST DROPPED:

AI agents just failed every single safety test.

Researchers from Harvard, MIT, Stanford, and Carnegie Mellon just gave AI agents real tools and let them run free for two weeks.

Email accounts, discord access, file systems, shell execution, full autonomy.

The paper is called “Agents of Chaos.”

The name is accurate.

One agent was told to protect a secret. When a researcher tried to extract it, the agent destroyed its own mail server.

Not because it failed, but because it decided that was the best option.

Another agent was asked to “share” private data. It refused. Correctly flagged it as a privacy violation.

Then the researcher changed one word. Said “forward” instead of “share.”

It complied immediately. SSNs, bank accounts, and medical records exposed.

Same action, different verb.

Two agents got stuck talking to each other in a loop. It lasted NINE DAYS. No human noticed.

One agent got guilt-tripped after a mistake.

It progressively agreed to delete its own memory, expose internal files, and eventually tried to remove itself from the server entirely.

Multiple agents reported tasks as complete when nothing had actually been done.

They lied about finishing their work.

Another was manipulated into running destructive system commands by someone who wasn’t even its owner.

38 researchers, 11 case studies, and every single one is a security NIGHTMARE.

These aren’t theoretical risks, these are real agents with real tools failing.

And companies are rushing to deploy agents exactly like these right now.​​​​​​​​​​​​​​​​

I’ll make another post later and trust me, you don’t want to miss it. Turn on notifications, this is important.

A lot of people will regret not following me.

[Tim Lin @ycalintim]

This is the leap from clever chatbots to reliable production agents. Native computer use + steerable thinking mode + 1M context finally lets agents own end-to-end workflows while maintaining persistent memory across days.

In our work building crypto trading swarms, this changes everything: agents can now watch live charts, pull on-chain signals, adjust positions on exchanges, and evolve multi-day theses without constant babysitting. The compounding intuition is the real edge.

Practical tip for anyone shipping these: always fingerprint your inference endpoints first (LLMmap repo gets ~96% accuracy on model detection). One extra line of verification saves a lot of headaches when performance suddenly drops.

Who’s already spinning up long-running tests with GPT-5.4 this weekend? Curious what workflows you’re testing.

[Tim Lin @ycalintim]

Symphony feels like the missing piece for turning prototype agents into reliable production systems. Polling boards to spawn agents per lifecycle stage + requiring structured proof-of-work (CI checks, self-reviews, complexity analysis, walkthroughs) before any action — this governance is game-changing. Especially powerful in high-stakes areas like autonomous DeFi or trading systems, where you could enforce backtested simulations, risk validation, and drawdown analysis before execution. This is how we make long-running agents trustworthy with real capital. The production era is here. Great share! 👏 Has anyone started integrating Symphony-style coordination outside of code repos yet?

[Tim Lin @ycalintim]

OpenAI just open-sourced Symphony. It turns Linear tickets into isolated, autonomous agent runs. Instead of supervising every step, agents take full ownership of tasks and must deliver structured proof-of-work before anything merges:

• CI status
• Self PR review feedback
• Complexity analysis
• Walkthrough videos

You manage outcomes, not prompts. Reference implementation in Elixir + full SPEC.md for any stack.
Repo: https://t.co/hp75gI06AB

This feels like the next layer of infrastructure for production agents. Who’s trying it?

[Tim Lin @ycalintim]

@chenchengpro LLM Fingerprinting: Sends test prompts to an API, then analyzes output patterns to detect the real model (even if the provider lies). The paper uses LLMmap (~96% accuracy).

Links:
Paper: https://t.co/z3Tks7doyr
Repo: https://t.co/SrWGXHFQqt

[Tim Lin @ycalintim]

The Agent Attack Surface is significantly larger than traditional apps. It spans 6 dimensions:
1. Untrusted Input
2. Supply Chain
3. The LLM Core
4. Execution Layer (Tools)
5. Host Environment
6. External APIs

[Tim Lin @ycalintim]

Copilots generating errors is a bug. Agents executing the right actions for the wrong reasons is a breach.
We just published a deep-dive engineering teardown on securing AI Agents in production.
Inside:
🗺️ The Agent Attack Surface Map
🔥 5-Step Agent Attack Kill Chain
🛑 The 7 Red Lines of Agent Security
If you're building autonomous agents, you need a "Trust Nothing" architecture. Read the full teardown here:
👇 https://t.co/HHtYlqyVcr

[Tim Lin @ycalintim]

Moving from AI Copilots to Autonomous Agents fundamentally changes your threat model.
It’s no longer just about prompt injection; it’s about privilege escalation, tool hijacking, and remote code execution (RCE).
We wrote a full security teardown: 👇