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. Review collected by and hosted on G2.com.

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. Review collected by and hosted on G2.com.

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. Review collected by and hosted on G2.com.