LangChain Blog

We are building this with https://lets.dev. We believe there will be great demand for less capable, but much more determinisic agents. I also recommend everyone to read "What is an agent?" by Harrison Chase. https://blog.langchain.dev/what-is-an-agent/

I'm playing around with LangChain and LangGraph (https://www.langchain.com/) and it seems like these enable just the sort of mechanisms mentioned.

Looks like they've parlayed it into some kind of business https://www.langchain.com/

Langchain wrote about LLMs and SQL, and although it's about SQL, it's still a great read, especially the references. https://blog.langchain.dev/llms-and-sql/ I'm also super keen for the 32k API limit for OpenAI, that's going to be great.

> 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… | https://aakashgupta.medium.com/2025-was-agents-2026-is-agent-harnesses… | 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…

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/

I get what your saying, however we don't need to be stuck with the Claude code harness. You may find this interesting. https://www.langchain.com/blog/tuning-the-harness-not-the-model-a-nemo…

It's a coding agent, for those wondering - https://blog.langchain.com/introducing-open-swe-an-open-source-asynchr…

I like the term "asynchronous coding agent" for this class of software. I found a couple of other examples of it in use, which makes me hope it's going to stick: - https://blog.langchain.com/introducing-open-swe-an-open-source-asynchr… - https://github.com/newsroom/press-releases/coding-agent-for-github-cop…

This article talks about it somewhat I think as well. Highlighting the difference between more advanced workflows and agentic style systems vs 'agents' https://blog.langchain.dev/how-to-think-about-agent-frameworks/

I found that [LangChain](https://www.langchain.com/langchain) has pretty good abstractions and better support for multiple LLMs. They also have a good ecosystem of supporting products - LangGraph and LangSmith. Currently supported languages are Python and Javascript.

interesting to contrast the recent memory releases - https://mastra.ai/docs/agents/01-agent-memory - https://blog.langchain.dev/langmem-sdk-launch/ - https://help.getzep.com/concepts#adding-memory not sure where all this is leading yet but glad people are exploring.

LangSmith integrates with OpenTelemetry: https://blog.langchain.dev/opentelemetry-langsmith/

Remember than LangChain raised $10m a few months ago https://blog.langchain.dev/announcing-our-10m-seed-round-led-by-benchm… (wait, over a year ago!)

Good thing they didn't raise money to develop this piece of crap. https://blog.langchain.dev/announcing-our-10m-seed-round-led-by-benchm…

Thank you - https://nextjs.org/blog/next-14 - https://supabase.com/ - https://ui.shadcn.com/ - https://openai.com/ - https://www.langchain.com/

Langchain previously had a nice blogpost about how they build their RAG chatbot, maybe there are some helpful hints in there: https://blog.langchain.dev/building-chat-langchain-2/

You might like this - https://www.youtube.com/watch?v=fWC4VxolWAk Blog on the same topic - https://blog.langchain.dev/evaluating-rag-pipelines-with-ragas-langsmi…

There are quite a few LLM monitoring tools in the market. But for monitoring (or evaluating) RAG systems, I found Ragas to be the most helpful: https://blog.langchain.dev/evaluating-rag-pipelines-with-ragas-langsmi…

Each of the problems you describe will become a slew of startups and open source projects. Compared to the typical web stack things are really immature and it'll be interesting to see how everything shakes out and fills in. As a sidenote, looks like langchain is working on some of this: https://www.langchain.com/langsmith.

They're well-funded; go ahead and criticize them. https://blog.langchain.dev/announcing-our-10m-seed-round-led-by-benchm…

I was referring to Langchain who raised $10mm from Benchmark https://blog.langchain.dev/announcing-our-10m-seed-round-led-by-benchm… I'm fairly Jerry Liu (LlamaIndex founder) already has angels or will see enough traction to warrant a seed.

For prototyping purpose I found that chromadb integration in langchain is very easy to use. That's said I'm not sure about production usage. https://blog.langchain.dev/langchain-chroma/

I just finished augmenting some of the Spider and WikiSQL data on huggingface [1] I initially intended to train a text-to-sql LLM that would take a natural language question and be provided the CREATE TABLE statements to provide some grounding for the response. So instead of hallucinating the column and table names by using the question alone, I was hoping the CREATE TABLE statement would limit the choices. We'll see if it's useful or not, but funny enough I came across this article after I finished the dataset.[2] I'd definitely like to see how others are doing it. [1] https://huggingface.co/datasets/b-mc2/sql-create-context [2] https://blog.langchain.dev/llms-and-sql/

Checkout this example: https://blog.langchain.dev/langchain-chat/ It's a chatbot based on the LangChain docs, a Python library for interacting with LLMs.

>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.

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/

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… 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