Luiz Simões

Building AI agents with LangChain • RAG, GraphRAG & tools • shipping in public

[Luiz Simões @luizsimoesai]

Just open-sourced 'agents-project-template'

Full-stack starter for AI agents:
- LangGraph + Aegra (self-hosted)
- JWT auth, multi-tenancy
- OpenAI · Anthropic · Ollama
- Next.js 16 + real-time streaming

From git clone to running app in minutes.

→ https://t.co/GVeX7DQXEa

[Luiz Simões @luizsimoesai]

@Vtrivedy10 Just started digging into evals after your other post. This makes the case even clearer. If I don't have my own benchmarks, I have no real way to know if a new model is actually better for what I'm building.

[Jensen Huang @JensenHuang]

For my first post, I’m sharing a letter @NVIDIA signed on why open models matter.

AI will transform every industry, power every company, and be built by every country.

Open models strengthen safety and cybersecurity, accelerate innovation and diffusion, and enable sovereignty.

The world needs both frontier closed models and frontier open models.

https://t.co/AUKzoQ5Ikb

[Luiz Simões @luizsimoesai]

What stuck with me most in this piece was the idea of compounding. The 100th interaction has to be better than the 1st, and that's what I want to chase. Not just building an agent that works today, but a system that gets smarter over time. Ownership beats adoption. @hwchase17

[Harrison Chase @hwchase17]

https://t.co/JdkAzhFLlA

[Luiz Simões @luizsimoesai]

@shashcricbuzz @hwchase17 Totally agree!

[LangChain @LangChain]

.@JensenHuang + @hwchase17 fireside chat:
✅ Why companies need open agent systems
✅ NemoClaw for LangChain Deep Agents blueprint

[Harrison Chase @hwchase17]

"Build your own Claude Code with Deep Agents"

Good article by the community showing how to build a Claude Code-like agent using Deep Agents

Especially relevant given how strong GLM-5.2 seems to be!

https://t.co/anPKlGYbcr

[Sydney Runkle @sydneyrunkle]

https://t.co/qV7B67dyxV

[Luiz Simões @luizsimoesai]

@harjjotsinghh Thanks! Three reasons: data stays on your infra, no per-run pricing surprises, and you control the stack. For agent products with real users, that matters.

[Luiz Simões @luizsimoesai]

Just open-sourced 'agents-project-template'

Full-stack starter for AI agents:
- LangGraph + Aegra (self-hosted)
- JWT auth, multi-tenancy
- OpenAI · Anthropic · Ollama
- Next.js 16 + real-time streaming

From git clone to running app in minutes.

→ https://t.co/GVeX7DQXEa

[Luiz Simões @luizsimoesai]

@compileandpush The auth layer between FastAPI and Aegra. Two systems, one token — it works well, but it's the part I'd test hardest before scaling.

[Andrej Karpathy @karpathy]

Personal update: I've joined Anthropic. I think the next few years at the frontier of LLMs will be especially formative. I am very excited to join the team here and get back to R&D. I remain deeply passionate about education and plan to resume my work on it in time.

[Viv @Vtrivedy10]

The Harness is a Context Manager on Behalf of the Model

What happens when the context window fills up and who decides? This decision is external to the model - The Harness designer must have some opinion here! Decisions like this are crucial in turning a model into a great product for end users.

The context window is a sacred boundary beyond which all model computation actually happens. Context engineering is important because designing what gets passed over this boundary is the main determinant of agent performance. Harness design is how you decide how this boundary gets managed.

Our create_agent primitive in LangChain exposes the one of the simplest Harnesses for builders to extend, a ReAct loop with support for tools, middleware (hooks), and model choice

It’s a great place to start in agent building because it forces you to think through and contend with all of the design details that transform a simple agent loop into a purpose-built agent for your tasks

The first time you hit the context boundary in a simple agent loop, the API will just error out and your agent run will end. The API contract only supports a max number of tokens.

A harness helps you get in line with the API contract by managing context via strategies like truncation, compaction, offloading, and targeted context eviction

This is just one decision to think about in Harness Design, many more come up as you build such as agent specialization via Subagents, Tool design, Skill design, and more. Each of these are important in extending a model to make it into a useful product for users.

create_agent is a great level of abstraction to start building agents. Builders can go up a level to deepagents for a more out of the box agent experience and even further to Fleet as a more out of the box product experience. Or they can go down to the runtime execution level to LangGraph like @caspar_br had talked about

starting from a simple harness to build a great agent helps you learn fundamentals of how models work + good design patterns that turn them into great agents and products

[Harrison Chase @hwchase17]

I’m going to build a bunch of deepagents examples (using deepagent deploy) over the next few days

What examples would people want to see?

[Luiz Simões @luizsimoesai]

@hwchase17 a coding agent that clones a repo, runs tests, and iterates on fixes autonomously.

[Zain Shah @zan2434]

Imagine every pixel on your screen, streamed live directly from a model. No HTML, no layout engine, no code. Just exactly what you want to see.

@eddiejiao_obj, @drewocarr and I built a prototype to see how this could actually work, and set out to make it real. We're calling it Flipbook. (1/5)

[Sydney Runkle @sydneyrunkle]

https://t.co/ZptJ7ZwvrS

[Luiz Simões @luizsimoesai]

@sydneyrunkle @hwchase17 Excellent addition! I'm enjoying creating agents with Deep Agents more and more each time.

[dex @dexhorthy]

there's a new concept I'm seeing emerging in AI Agents (especially coding agents), which I'll call "harness engineering" - applying context engineering principles to how you use an existing agent

Context engineering -> how context (long or short, agentic or not) is passed to an LLM to get the best results

You do context engineering when you prompt an llm, and you do a LOT of context engineering when you design a coding agent harness

But there's another layer on top of the core tool-calling orchestration and agentic RAG that happens in the agent. For claude code, it's the commands, hooks, skills, agents, mcps, etc that a consumer of the tool plugs into the existing harness.

Harness engineering -> How do you engineer the *integration points* of a given agent to get the best results?

You can't do harness engineering without understanding context engineering, and you can't do context engineering without building intuition around LLMs

[Andrej Karpathy @karpathy]

LLM Knowledge Bases

Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge (stored as markdown and images). The latest LLMs are quite good at it. So:

Data ingest:
I index source documents (articles, papers, repos, datasets, images, etc.) into a raw/ directory, then I use an LLM to incrementally "compile" a wiki, which is just a collection of .md files in a directory structure. The wiki includes summaries of all the data in raw/, backlinks, and then it categorizes data into concepts, writes articles for them, and links them all. To convert web articles into .md files I like to use the Obsidian Web Clipper extension, and then I also use a hotkey to download all the related images to local so that my LLM can easily reference them.

IDE:
I use Obsidian as the IDE "frontend" where I can view the raw data, the the compiled wiki, and the derived visualizations. Important to note that the LLM writes and maintains all of the data of the wiki, I rarely touch it directly. I've played with a few Obsidian plugins to render and view data in other ways (e.g. Marp for slides).

Q&A:
Where things get interesting is that once your wiki is big enough (e.g. mine on some recent research is ~100 articles and ~400K words), you can ask your LLM agent all kinds of complex questions against the wiki, and it will go off, research the answers, etc. I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents and it reads all the important related data fairly easily at this ~small scale.

Output:
Instead of getting answers in text/terminal, I like to have it render markdown files for me, or slide shows (Marp format), or matplotlib images, all of which I then view again in Obsidian. You can imagine many other visual output formats depending on the query. Often, I end up "filing" the outputs back into the wiki to enhance it for further queries. So my own explorations and queries always "add up" in the knowledge base.

Linting:
I've run some LLM "health checks" over the wiki to e.g. find inconsistent data, impute missing data (with web searchers), find interesting connections for new article candidates, etc., to incrementally clean up the wiki and enhance its overall data integrity. The LLMs are quite good at suggesting further questions to ask and look into.

Extra tools:
I find myself developing additional tools to process the data, e.g. I vibe coded a small and naive search engine over the wiki, which I both use directly (in a web ui), but more often I want to hand it off to an LLM via CLI as a tool for larger queries.

Further explorations:
As the repo grows, the natural desire is to also think about synthetic data generation + finetuning to have your LLM "know" the data in its weights instead of just context windows.

TLDR: raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki, and all of it viewable in Obsidian. You rarely ever write or edit the wiki manually, it's the domain of the LLM. I think there is room here for an incredible new product instead of a hacky collection of scripts.