LangChain Blog

> Also, my main gripe with parquet (single table per file) is not even addressed, so, also the name is a bit hyped up.

This is really more of an expectation that has been put on file formats by the query engines. Spark/Datafusion/DuckDB wouldn't really know what to do with a multi-table file.

> Parquet is unfortunately very good just by virtue of being first, and so widely supported

IMO that is not how technology works. It is great that Parquet is so good at a lot of things, but that does not mean just because it came first that it deserves to be the only analytic file format forever.

> Its main result seems to be improved random access which, although certainly welcome, is not the point of columnar storage, as columnar storage was invented to exchange random access for something else: fast analytics

Fast analytics, as well as newer ML-shaped workloads, are inherently mix of batch scans and random access.

Some of the authors of F3 previously authored another paper that goes into the details of the shortcomings of Parquet

https://www.vldb.org/pvldb/vol17/p148-zeng.pdf

All of the newer formats that popped up recently (Vortex, Lance, F3 now) have been working on solving the problems outlined in that paper.

Lance has some interesting ideas, Vortex focuses on extensibility and performance by replacing all of Parquet's black-box encoders with fully transparent encodings. This solves the tradeoff between bulk and element decoding, allowing you to have efficient full scans…

A model cannot read your mind. It can guess, and those guesses are more likely to be wrong if you don't give it the right input, and model performance gets worse if not steered/curated properly. The output depends on the input.

https://medium.com/@adambaitch/the-model-vs-the-harness-which-actually-matters-more-59dd3116bb31 | https://aakashgupta.medium.com/2025-was-agents-2026-is-agent-harnesses-heres-why-that-changes-everything-073e9877655e | https://x.com/Hxlfed14/status/2028116431876116660 | https://www.langchain.com/blog/the-anatomy-of-an-agent-harness

(I don't think anecdotes are useful in these comparisons, but I'll throw mine in anyway: I use GPT-5.4, GPT-5.3-Codex, Gemini-3-Pro, Opus, Sonnet, at work every week. I then switch to GLM-5.1, K2-Thinking. Other than how chatty they get, and how they handle planning, I get the same results. Sometimes they're great, sometimes I spent an hour trying to coax them towards the solution I want. The more time I spend describing the problem and solution and feeding them data, the better the results, regardless of model. The biggest problem I run into lately is every website in the world is blocking WebFetch so I have to manually download docs, which sucks. And for 90% of my coding and system work, I see no difference between M2.5 and SOTA models, because there's only so much better you can get at writing a simple script or function or navigating a shell. This is why Anthropic themselves have always told people to use Sonnet to…

>I’ve been using Cursor and other AI coding tools, and I noticed a pattern: they go from requirements → code → fix when it breaks. It works, but it’s reactive. I write what I want, it half-understands, breaks something, and I patch it.

This is last generation AI coding. I was literally using qwen2.5 coder instruct yesterday; so i havent moved on yet.

Next gen is with similar options to: https://github.com/Significant-Gravitas/AutoGPT

or https://www.langchain.com/agents

honestly havent tried either of those.

>What I wish existed is a flow like this: Requirements → Generate Tests → Generate Code → Run Tests

Isnt that what github copilot is doing? This is what i didnt like about it; but im sure more talented devs appreciate what it's doing.

>Would you use something like this? Would you pay for it (e.g. Cursor-level pricing, ~$20/mo)? What would break this in your workflow?

Why not go for the sky?

Requirements -> fully generated project that just works and i dont care how it got there. Scotty on the enterprise was just writing prompts and never looking at unit tests.

I trained the agent itself to write SQL, run it, check results, then rewrite until correct. The write and rewrite policies are optimized with RL, using a client–server setup in Agent Lightning and a LangGraph state machine. On a 500-sample Spider eval subset, Qwen2.5-Coder-3B with 4096 context reaches 80.4% at three turns of write and rewrite, 80.2% at one turn. After training, model Qwen2.5-Coder-1.5B can be even better than Qwen2.5-Coder-3B (untrained). I have compared multiple models and settings, hoping to shed light on tuning AI agents.

Full article: https://medium.com/@yugez/training-ai-agents-to-write-and-self-correct-sql-with-reinforcement-learning-571ed31281ad

Related projects:

- Agent Lightning as the glue: https://github.com/microsoft/agent-lightning

- verl for RL algorithms: https://github.com/volcengine/verl

- vLLM for efficient rollouts: https://github.com/vllm-project/vllm

- AgentOps for collecting training data (telemetry): https://github.com/AgentOps-AI/agentops

- LangGraph for agent orchestration: https://www.langchain.com/langgraph

In the ~2 year timeframe we'll be using RAG.

Longer term it gets more interesting.

Assuming we can solve long (approaching infinite) context, and solve the issues with reasoning over long context that LangChan correctly identified[1] then it becomes a cost and performance (speed) issue.

It is currently very very expensive to run a full scan of all knowledge for every inference call.

And there are good reasons why databases use indexes instead of table scans (ie, performance).

But maybe we find a route forward towards adaptive compute over the next two years. Then we can use low compute to find items of interest in the infinite contest window, and then use high compute to reason over them. Maybe this could provide a way forward on the cost issues at least.

Performance is going to remain an issue. It's not clear to me how solvable that is (sure you can imagine ways it could be parallelized but it seems likely there will be a cost penalty on planning that)

[1] https://blog.langchain.dev/multi-needle-in-a-haystack/

Zep author here. LangChain is a great framework and has a very broad and active ecosystem. Many of LangChain's core components, such as chat history "memory," history summarization, entity extraction, vector search, and more, don't scale well in production. They operate in memory and often synchronously within the chat loop, resulting in poor user experiences and limiting deployment options.

You can use third-party ecosystem integrations with external SQL databases, vector databases, etc to fix some of these issues. This requires some know-how, infrastructure, and time. Zep's building blocks are turn-key solutions to these challenges and offered in a single service.

The Zep GitHub project, website, and demo video provide a good overview of the project's functionality and how the service solves these issues.

This blog post on the LangChain website offers some benchmark data using Zep vs LangChain's core memory components: https://blog.langchain.dev/zep-x-langchain-slow-chatbots/