LangSmith Agent Engineering Platform by LangChain (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.

What do you like best about the product?

What I like most about Langsmith is its debugging features. In my application, I connect with more than one agent, so it helps me distinguish between the AI agent and the agent’s internal mechanisms, and check whether they are returning the correct documents or not. It also estimates the token cost that the agent uses.

What do you dislike about the product?

What I dislike about LangSmith is that it can feel overwhelming when you first start using it. There are a lot of concepts—projects, traces, runs, datasets, experiments, and evaluations—so it takes time to understand how everything fits together. Sometimes it also creates problems when the agent workflow gets more complex, and I’m trying to track down a particular answer.

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

The best part is that it tracks all my agents connected to my application. It also helps with debugging when something goes wrong or incorrect data comes in whether the issue is from the LLM or from my documents—so I can easily find out the cause. After I deploy the project, it keeps monitoring my application, estimates what cost it takes, and shows the running status of the project.

What do you like best about the product?

I like that LangSmith makes it easier to track and understand what is happening with an LLM application. The tracing feature is useful when I need to check individual steps and find where an issue is coming from. The interface is fairly clean, and it doesn't take too long to get familiar with the main features.

What do you dislike about the product?

There are quite a few features and settings, so it can take some time to understand everything when you are new to the platform. The pricing can also become a consideration as usage increases.

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

It helps with debugging and monitoring AI workflows by giving more visibility into requests, responses, and individual steps. Instead of trying to understand an issue only from application logs, I can use the traces to get a clearer picture of what happened. This makes troubleshooting and testing AI applications more manageable.

What do you like best about the product?

What I like most about LangSmith is how much easier it makes debugging AI applications. With traditional apps, you can usually check the logs and quickly understand what went wrong, but with LLM workflows it’s often hard to tell whether the problem is in the prompt, retrieval, the model’s response, or some intermediate step. LangSmith makes that much clearer by letting you trace the entire flow end to end. The UI is also very good and intuitive, which makes it easier to navigate and use while you’re troubleshooting.

What do you dislike about the product?

One thing I don’t love is that LangSmith can feel a bit overwhelming at first, especially when I’m juggling multiple traces, datasets, and evaluations. There’s definitely a learning curve before it becomes clear how to organize everything in a way that feels efficient and consistent.

As an application grows, I also wish there were simpler ways to quickly surface the most important issues or bottlenecks, without having to dig through several traces to find what matters. That said, these are relatively minor concerns overall, and the observability LangSmith provides still makes it very useful for building and debugging LLM applications.

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

LangSmith helps address the challenge of understanding and debugging complex LLM workflows. It provides clear visibility into prompts, model calls, retrieval, and intermediate steps, which makes it much easier to pinpoint where things go wrong.

As a result, I save development time and can experiment with, iterate on, and improve LLM applications with more confidence.

What do you like best about the product?

I like how LangSmith helps me trace, debug, and monitor AI applications. It makes it much easier to understand model outputs and spot issues during development, so I can troubleshoot more effectively as I build. LangSmith provides good value for AI development and debugging. Its tracing, monitoring, and evaluation features help save development time and make it easier to identify and fix issues.

What do you dislike about the product?

The interface can feel a bit complex at first, and it may take new users some time to fully understand all of the tracing and monitoring features.

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

LangSmith helps me trace and debug AI applications, spot issues in model outputs, and keep an eye on performance. Overall, it makes development and testing smoother, and it saves me time when I need to troubleshoot.

What do you like best about the product?

The tracing view is the strongest part. Being able to see every step of a chain or agent run, prompts, tool calls, intermediate outputs, and latency, makes debugging much faster. I also like the dataset and evaluation features; they help me test prompt changes more systematically instead of guessing.

What do you dislike about the product?

The UI can feel heavy when you have a lot of traces open. Filtering and finding specific runs sometimes takes longer than it should. Pricing also adds up quickly once you move beyond light usage, especially if multiple people on the team need access.

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

Before LangSmith, debugging LLM workflows meant digging through logs or print statements. Now I can quickly see where a prompt or a tool call is failing and fix it. It has reduced the time I spend investigating issues and made it easier to improve the reliability of our AI features.