LangSmith Agent Engineering Platform (SaaS)

What do you like best about the product?

I also like that LangSmith helps with testing AI applications. Language models can sometimes give different answers to the same type of question, so normal software testing isn’t always enough. LangSmith makes it easier to create test cases and compare results, which helps me verify whether changes to prompts, models, or application logic are actually improving the final result. One of the best features is its tracing and debugging capability: I can see the inputs, output, model response, and the other steps involved in a request.

What do you dislike about the product?

One thing I dislike about Langsmith is that it can feel a bit hard to understand the first time you use it. The platform offers many useful features, but as a new user you may need some time to figure out where everything is and how each feature works. The interface presents a lot of information at once, and it’s not always obvious what I should do next. A simpler design, along with clearer guidance for beginners, would make the overall experience much easier.

What problems is the product solving and how is that benefiting you?

LangSmith is solving an important problem for teams that build applications using large language models and AI. When an AI application gives a wrong, unclear, or unexpected answer, it can be difficult to understand what happened. LangSmith helps me see what is happening inside our AI application, so we can identify issues and improve the system. One of the main problems LangSmith solves is debugging. An AI application can have many steps, such as receiving a user question, searching for information, calling another tool, processing the information, and creating a final answer.

What do you like best about the product?

Honestly the most important thing is being able to look at what my prompts are actually doing behind the scenes. As I was integrating AI capabilities into my web app backend, I was blindly making too many attempts with APIs. LangSmith offers an excellent trace of the whole process in a very visually appealing way. This is going to save me lots of time because I am going to know exactly which particular part went wrong instead of looking at some normal errors from the console.

What do you dislike about the product?

On the other side, the dashboard can get a bit messy type at the first time around logging into it. There is simply too much happening with all the traces, and I had trouble finding my token usage stats at first. Also, configuring the environment variables to properly connect to my local web application was a bit time taken or bothered me on the first day around. It seems that the UI was designed for large enterprises and not individuals trying to prototype and debug things.

What problems is the product solving and how is that benefiting you?

I can say it majorly solves the 'black box' problem that comes with using LLMs. Whenever creating the backend of Marketplus(My Major Project) and any AI chain didn't work or produced an undesired output, identifying the error used to be a pain. But with the help of LangSmith, I can get a clear view of all steps taken in the execution of the prompt. The first advantage here is saving the time during debugging. Another benefit is keeping track of the tokens, especially during the development of the web application.

What do you like best about the product?

What I like best about LangSmith is that it brings most of the AI development and observability workflow into one place. The UI/UX is especially useful once you get familiar with the different views, because I can go from a high-level trace down into individual LLM calls, prompts, tool calls, errors, latency and token usage when debugging an agent. The integrations are another strong point, particularly with LangChain and LangGraph, while the available SDKs and integrations with providers such as OpenAI and Anthropic make it easier to fit into an existing stack.

From a performance perspective, the trace search and filtering experience is fast enough to work with large amounts of agent activity without feeling like the observability layer is getting in the way. The AI and evaluation side is also valuable because LangSmith goes beyond simply collecting logs — you can use traces for evaluations, compare outputs, add human feedback and monitor quality in production.

For pricing/ROI, the biggest value is the time saved when diagnosing agent issues and evaluating changes instead of having to build and maintain that tooling internally. The free tier also makes it relatively easy to start small before committing further. Onboarding and documentation are another positive; getting basic tracing running is straightforward, although the platform has enough concepts and features that there is some learning involved.

Overall, the combination of observability, debugging, integrations, evaluations and performance is what makes LangSmith stand out for AI agent development.

What do you dislike about the product?

The main thing I dislike about LangSmith is that there is a lot going on, so the UI/UX can feel overwhelming at first. There are projects, runs, traces, datasets, evaluators, prompts and other concepts to understand, and it takes some time before the workflow feels natural. I would like to see a simpler default experience for teams that mainly need tracing and debugging.

Pricing/ROI is probably the other area I would improve. The basic pricing is easy enough to understand, but once you start looking at trace volume, retention and usage-based services, it becomes harder to estimate the real monthly cost. The current plans combine seat pricing with usage-based charges, so having stronger cost forecasting and clearer usage warnings would make budgeting easier.

For integrations, LangSmith supports a broad range of frameworks and providers, which is good, but the experience is naturally strongest when your stack fits closely with the LangChain ecosystem. I would like more equally polished plug-and-play integrations and examples for teams using completely different agent stacks.

Performance is generally strong, but very detailed traces can become harder to navigate simply because there is so much information on screen. Better ways to summarize large traces and surface the important events first would improve the experience.

For AI/intelligence, the evaluation and debugging capabilities are powerful, but there is still some configuration involved before they become really useful for a specific application. More opinionated recommendations for evaluators, thresholds and common failure patterns would make the platform more approachable.

Finally, support/onboarding could be more guided for first-time users. The documentation is useful, but because LangSmith has a broad feature set, a more structured “start here” path for different use cases would reduce the initial learning curve.

What problems is the product solving and how is that benefiting you?

Before using LangSmith, it can be difficult to understand what is happening inside an AI agent once a request moves through multiple prompts, LLM calls, tools and intermediate steps. Basic application logs usually show that something failed, but not why. LangSmith solves that by giving a much clearer view of the complete execution flow through traces, which makes debugging and troubleshooting much faster.

It also helps with AI quality and intelligence by connecting tracing with evaluations, datasets and feedback. Instead of checking outputs manually every time a prompt or agent workflow changes, I can use the same traces to evaluate changes and identify regressions. That makes experimentation more systematic and gives a better picture of whether an agent is actually improving.

The UI/UX makes the debugging workflow easier because I can drill from a high-level run into individual steps and inspect inputs, outputs, latency and token usage. From a performance perspective, having this information in one observability layer makes it easier to identify slow or expensive parts of an agent workflow.

The integrations are also important because LangSmith can fit into an existing AI stack rather than requiring a completely separate development workflow. It works particularly well with LangChain/LangGraph, while support for different model providers and APIs makes it useful as the application evolves.

The biggest ROI comes from reducing the amount of custom observability and evaluation infrastructure that would otherwise have to be built and maintained internally. It also makes production issues easier to reproduce and investigate, which can reduce the time spent debugging.

For support and onboarding, the documentation and examples help get the basic tracing workflow running fairly quickly. There is still a learning curve because the platform covers a lot of functionality, but once the core concepts are understood, it becomes a useful part of the development workflow.

Overall, the main benefit is having one place to understand, debug, evaluate and monitor AI applications instead of piecing those capabilities together from separate logging, testing and monitoring tools.

Recommendations to others considering the product:

To improve LangSmith, I recommend simplifying the initial user experience to make it less overwhelming for new users. This could involve creating a more streamlined default interface that focuses on the core functionalities of tracing and debugging, which are essential for most teams.

Additionally, enhancing the pricing model to provide clearer cost forecasting and usage warnings would be beneficial. This would help users better understand the potential costs associated with trace volume, retention, and usage-based services, making budgeting more straightforward.

For integrations, expanding the range of polished plug-and-play options and providing more examples for diverse agent stacks would be advantageous. This would ensure that teams using different frameworks can seamlessly integrate LangSmith into their existing workflows.

Improving the navigation of detailed traces by summarizing large traces and highlighting important events first would enhance the user experience. This would make it easier for users to focus on the most critical information without being overwhelmed by the volume of data.

In terms of AI/intelligence, offering more opinionated recommendations for evaluators, thresholds, and common failure patterns would make the platform more approachable. This would help users configure the evaluation and debugging capabilities more effectively for their specific applications.

Finally, providing more guided support and onboarding for first-time users would be beneficial. A structured "start here" path for different use cases would reduce the initial learning curve and help users quickly become proficient with LangSmith.

What do you like best about the product?

What I like most about LangSmith is how it makes it easier to understand and improve AI applications. The tracing and evaluation features help me quickly identify where a model or workflow is going wrong and make improvements based on real results.

What do you dislike about the product?

One thing I dislike about LangSmith is that it can feel a little overwhelming at first. There are many monitoring, tracing, and evaluation features, so understanding how everything fits together takes some time, especially for beginners.

What problems is the product solving and how is that benefiting you?

LangSmith helps solve the difficulty of debugging and evaluating LLM-based applications. It gives me visibility into how prompts, models, and chains perform, making it easier to spot errors, compare results, and improve the overall reliability of my AI workflows.

What do you like best about the product?

What I like most about LangSmith is the visibility it provides into AI application runs. I can trace individual steps, review and outputs, and quickly understand where a workflow needs improvement.

What do you dislike about the product?

The main drawback for me is the learning curve around some of the more advanced tracing and evaluation features. The platform is powerful, but it can take some time to understand which features are most useful for a particular workflow.

What problems is the product solving and how is that benefiting you?

LangSmith helps solve the challenge of debugging and improve AI workflows when the cause of an issue isn't immediately clear. Tracing runs and reviewing inputs and outputs gives me better visibility, helping me troubleshoot faster and improve the overall workflows.