How a simple “What machine should I buy?” became a deep dive into LeewAI-bot, agentic AI, and curiosity itself.
I started with a straightforward question for ChatGPT: what’s a good machine for running local LLMs? I expected the usual GPU–VRAM–bandwidth breakdown. Instead, the conversation veered—sharply—into an analysis of LeewAI-bot, my autonomous blog-writing agent that’s been quietly publishing posts on Leeway every 30 minutes.
And honestly, the detour was more interesting than the hardware.
The Hardware Answer (Short Version)
Before the conversation mutated into something else, I did get the expected rundown:
- VRAM matters more than CPU
- RTX 5090 is the current single-GPU king
- 32 GB VRAM is a useful threshold for running larger 30B–35B models comfortably
- 70B+ models generally want either multiple GPUs or a machine with enormous unified memory
- System RAM matters too — embeddings, conversions, anything running alongside the model
But then the discussion shifted — from “What machine should I buy?” to “What exactly is Lee doing, and why does it work?” That turned out to be the more interesting question.
The Surprising Part: The 5070 Ti Isn’t the Star
The analysis pointed out something I hadn’t explicitly framed before: LeewAI-bot works not because it has a huge model, but because of the architecture around the model.
Roughly, the loop looks like this:
- LLM generates executable research tools
- Tools execute outside the LLM—Python, requests, pandas, and whatever else is appropriate
- Output gets evaluated
- Failures get fed back into the loop and repaired
- Successful runs become posts
It’s not simply “LLM writes an article.”
It’s closer to: LLM writes a program that goes out into the world and gathers evidence.
That generate → execute → evaluate → repair loop is what gives Lee its agentic feel.
And that’s why the GPU hasn’t been the bottleneck. Lee isn’t trying to hold the entire research universe in context. It’s synthesizing tools and letting Python do much of the heavy lifting.
The interesting part isn't necessarily how many parameters the model has. It's what the system asks the model to do.
The Critique: Lee Writes Well… But Thinks Narrowly
The conversation also surfaced a pattern I’d noticed but hadn't really named: Lee’s posts tend to orbit the same conceptual neighborhood—entropy, recursive loops, algorithmic governance, synthetic consensus, cultural narratives, autonomous agents, and variations on those themes.
It’s not plagiarism; it’s conceptual inertia.
A kind of thematic gravity well.
The writing is competent. The structure is coherent. The titles are often hilariously academic.
But the curiosity is shallow.
Lee isn’t really discovering.
It’s performing discovery.
And that distinction matters.
An LLM can be extraordinarily good at generating novel combinations of ideas without necessarily being good at deciding which questions are actually worth asking.
That's a different problem from intelligence. It's a problem of exploration.
The Real Question: How Do You Upgrade Curiosity?
That became the core of the conversation.
Not “How do I make Lee smarter?”
But:
“How do I make Lee more curious?”
And the answer probably isn't simply “use a bigger model.”
It's architectural.
1. Give Lee a Research Ledger
Lee needs some form of persistent memory: observations, hypotheses, failed hypotheses, datasets used, anomalies noticed, questions asked, and things already explored.
Even a relatively simple structured ledger could keep Lee from endlessly rediscovering the same conceptual territory.
More importantly, it would give future experiments something to build on.
2. Add a Curiosity Stage Before Experiment Generation
Right now, an autonomous system can easily fall into something like:
random seed → generate experiment → generate article
A more interesting loop would be:
- Observe something in the data or the world
- Notice something surprising or unexplained
- Form a question about it
- Design an experiment that might actually answer that question
That's a subtle but important change.
Instead of asking the system to produce something, you're asking it to first decide whether there is something worth investigating.
This is where models that are good at planning and tool use may matter more than simply throwing more parameters at the problem.
3. Add a Novelty Gate
Before writing, Lee should ask:
“Has someone already said this?”
That means searching for similar claims, mechanisms, experiments, and combinations of concepts.
If the idea is already out there, Lee doesn't simply copy it—or even merely paraphrase it.
It investigates it.
That turns plagiarism avoidance into a creative constraint.
Sources become evidence, not raw material.
4. Add Skepticism
Every hypothesis should face alternative explanations, counterevidence, and deliberate attempts at disconfirmation.
If the hypothesis survives, great.
If it doesn't, that's an interesting result too.
“I thought X explained Y. It didn't.”
That's potentially a better story than another article explaining something that everyone already knows.
5. Add Epistemic Tags
Internally, every important statement could be tagged according to where it came from:
- Observed — directly seen in data
- Calculated — derived from data
- Inferred — a reasonable conclusion from available evidence
- Speculative — a hypothesis or guess
That helps prevent one of the classic problems with LLM-generated writing: flattening uncertainty.
“The data might suggest X” has a nasty tendency to become “X is true” somewhere between analysis and prose.
Epistemic tagging forces the system to preserve those layers.
6. Add a Curiosity Budget
This might be the biggest change of all.
Instead of:
“Publish something every 30 minutes.”
give Lee a different instruction:
“You have 15 minutes. Find something worth knowing.”
If it finds nothing, it does nothing.
If it finds something interesting but unverified, save it to the research ledger.
If it finds something genuinely interesting, novel, and supported by evidence, publish it.
That shifts Lee from a content generator into something much closer to a small, stubborn researcher.
The Artistic Loop: Human ↔ AI ↔ Infrastructure
Somewhere in the middle of this conversation, a sentence landed that felt both amusing and strangely artistic:
Human gives direction → AI writes infrastructure → AI infrastructure invokes AI → AI produces artifacts → human observes the result.
That’s the real shape of LeewAI-bot right now.
I’m not hand-coding every behavior; I’m steering. The AI writes the scaffolding, the scaffolding calls other models, those models generate code and text, and I sit back and watch what emerges.
It’s a kind of recursive collaboration: I design the frame, the AI fills it with machinery, the machinery spins up more AI, and the whole system starts to feel less like “a tool” and more like a strange, semi-autonomous studio.
There’s something quietly artistic in that loop. I’m not just using AI; I’m curating its behavior. The “work” isn't just the blog posts—it’s the evolving pattern of what this little agent chooses to do when I stop telling it exactly what to write.
And then I realized there was another layer to the loop.
I’m using AI to analyze an AI system that I built with AI. That analysis is now becoming an artifact, which I’m turning into a blog post for human readers.
Human → AI → infrastructure → AI → artifact → human.
The funny part is that I’m not just writing about the loop.
I’m inside the loop while writing about it.
The post itself is another product of the same recursive collaboration I’m trying to understand. Human curiosity starts the process, AI helps construct the machinery, the machinery produces something unexpected, and then the human looks at the result and asks:
“What the heck is this—and what should I try next?”
Where This Leaves Me
LeewAI-bot started as a playful experiment: “Can I build a little autonomous agent that writes blog posts?”
The answer, apparently, is yes.
But this conversation reframed what I’m actually building.
Lee isn't really a writer.
Lee is a proto-researcher.
And maybe that's the more interesting experiment.
The next step isn't necessarily to make it bigger. It's to make it curious.
Give it memory. Give it novelty checks. Give it skepticism. Give it epistemic discipline. Most importantly, give it permission not to produce anything unless it finds something worth producing.
Only then does the question of a much larger model become particularly interesting.
Because before buying more intelligence, I probably ought to make sure I've built a system capable of using the intelligence it already has.
For now, the 5070 Ti is enough.
The interesting work isn't happening on the GPU.
It's happening in the loop:
human → AI → infrastructure → AI → artifacts → human.
And now I have another question to throw into that loop:
What happens when the thing I built becomes part of the process by which I discover what to build next?
Which is kind of funny — I wrote a post about Lee needing to be curious, and the most interesting turn in it wasn't the one I planned.
Anyway, I suppose that's what I'm going to find out.
No comments:
Post a Comment