We’re hiring a builder/operator hybrid to work on agentic quant research & trading systems
The Work:
- long-running multi-agent systems
- live trading workflows + terabyte-scale data
- high impact, broad scope
The Team:
- small, very strong, self-funded
- traders + engineers running live systems
- years of proven edge
- fully remote
don’t send a resume
dm me with links to what you’ve built
I’m letting gpt5 drive prompt eng and am genuinely so so shocked at how good the results are. Kind of insane. I’m starting to think that the DSPy philosophy was right all along
A lot of new followers over the past month or so. Figured it’s time to reintroduce myself:
Hey! I’m Jamie.
Here’s how I got here
> Started studying ML when I was 19
> Broke into Data Science after undergrad
> Pivoted from researcher to engineer (Being a builder is way cooler imo)
> Was early to AI eng, hacking in my free time
> Landed on an AI eng team at BigCo
> Was grinding to break out of the wagie cage
> Launched a ton of projects with little engagement
> Then one afternoon I built https://t.co/14tG6uY7PG and my life changed forever
> Was the catalyst for massive follower growth
> And opened doors to be at the bleeding edge of agent eng @ House Kling
This journey has been insane and I feel so lucky & grateful tbh
If you are early on a path similar to mine: being on X is a good start, but I cannot stress enough how important it is to *post your work*. Being able to point to it and say “Yes I can build *this* for your company” will get you paid
Agent Design Pattern: Parallel Rollouts
Inspired by Tree-of-Thought [1] and @corbtt's Universal Reward Function [2], lately I've been using a best-of-n pattern (dubbed “parallel rollouts” internally) and seeing consistently strong results
When designing an agent, retry-on-failure is generally a good practice, but it’s costly (in terms of latency). Instead, let’s just assume the agent will act sub-optimally:
> Let the agent perform N rollouts concurrently
> Grade each rollout via LLM-as-a-judge
> Select the best one
> No retries needed
It’s a simple tradeoff: higher cost for lower latency - worth it for high margin agentic tasks (not for everyone)
Note: This idea of search and selection is not novel (see MCTS, AlphaGo, etc) but in the context of agents branching is underused
Life Update!
- Turned down an ML eng offer @ Meta (no it wasn’t $100m)
- Stumbled upon the opportunity of a lifetime building AI Agents for Quant
- Quit my job (was a great job, sad to go)
Now it’s time to go deep on Agents/Quant. Who are the best follows in this space? Lmk
Annnnnnd if you would like to see this project continue: every dollar donated here will go directly into my OpenAI account for more tests: https://t.co/GwaoqYAVZF
Poker Bench results are in.
I simulated 100 games of Texas Hold 'em between:
- 4.1-mini, 4.1-nano, 4o-mini (base)
- 4.1-mini, 4.1-nano, 4o-mini (with reasoning)
27 million tokens later, here’s what I learned:
Confession: I regret vibe coding so much over the past year or so and am actively trying to depend less on LLMs for writing code. I can't help but feel like my focus, debugging skills, and syntax muscle memory is worse off. Trading low level abilities for speed and product sense is good in the short term, but is not sustainable over a long career in technology.
How to Vibe Code without getting lost in the sauce
My take on the stages of Vibe Coding as software products evolve from demo to production
Demo: Pure Vibes
Get the demo out as fast as possible despite the grossness of the code. Validate quickly. A landing page, a notebook, or a simple API will do. You’re accruing tech debt at a rapid pace, so finish this stage fast (faster than an MVP).
Iterating: Vibes Plus Taste
Time to iterate and add features. Patterns will emerge, lean in, refine, and enforce structure. You’re still allowed to use AI-generated code, but you should resist the urge to totally vibe out, the patterns built today will make or break your velocity tomorrow. Practical advice: double down on extendibility with strong typing and clean interfaces
Production: 10x Vibe Engineer
Now that patterns are stable, codegen becomes EVEN MORE reliable. Write your code like a 10x wizard dev, and your AI will output 10x wizard code (LLMs are very impressionable). Queries like “Add feature Y accessing data from table X” are incredibly powerful because the LLM can extrapolate from existing patterns. Frontier models are not bound by intelligence, they are context-bound, so you must ensure that you give them proper context to cook.
Start fast, iterate intentionally, and reap the rewards of long-term well-written codegen
I'm a huge fan of OpenAI, but this is bad.
Evals that lock you into a single LLM provider defeat the entire purpose of an evaluation platform. In a world where LLM benchmarks and leaderboards are being gamed and increasingly meaningless, running your own evals (across models) on the tasks you care about matters more than ever.
So while I commend OpenAI for making LLMops potentially more convenient, I don't recommend locking yourself into this platform.