# LangSmith Trace Access Controls Are Not Data Redaction

LangSmith's new Enterprise controls restrict who sees trace content. Separate that decision from what you send, then test customer boundaries with synthetic traces.

By Paras Madan | 2026-11-18


An engineer investigating a slow agent may need to see which tool stalled, not the customer's entire conversation. LangSmith's new trace controls address that distinction. They do not, by themselves, stop sensitive information from reaching the tracing service.

LangChain's [November 17 announcement](https://www.langchain.com/blog/protect-sensitive-data-in-your-traces-new-controls-in-langsmith) introduces three controls for Enterprise plans: separate visibility for trace inputs and outputs, permissions managed through user groups, and trace-level policies using root run metadata. Engineers can inspect run structure and performance information while restricted content remains hidden.

The important qualification is that this access-control design retains complete traces in LangSmith. Hiding content from a particular teammate is different from removing it before upload. I would make those two decisions separately before changing production instrumentation.

## First decide what should leave the application

Start with a short inventory of what your agent records. Include customer messages, retrieved documents, tool arguments, tool results, error text and metadata. For each, ask whether the tracing backend needs the original value, a sanitized version, or no value at all.

LangChain's [sensitive-data logging guide](https://docs.langchain.com/langsmith/mask-inputs-outputs) documents controls that operate before data reaches the backend. These include hiding inputs and outputs, transforming metadata, selective masking and conditional tracing. The SDK supports `LANGSMITH_HIDE_INPUTS=true` and `LANGSMITH_HIDE_OUTPUTS=true`; function-level and request-level approaches offer narrower control.

Those are different choices from granting a support engineer permission to inspect a stored conversation. If your internal requirement is “never send this value,” a viewer restriction is not the corresponding solution. If the requirement is “store this for approved investigations, but limit readers,” access controls address that part of the design.

Start with synthetic customer records rather than production content. Recognizable test values make filtering failures easier to spot.

## Treat metadata as an access-control input

The [ABAC documentation](https://docs.langchain.com/langsmith/abac) distinguishes project resource tags from metadata on a trace's root run. Metadata conditions currently support equality matching. Policies must be attached to a role or user group before they take effect, and matching deny policies override allows.

That makes the source of a customer identifier worth reviewing. My recommendation is to derive access-related metadata from trusted application context, not from text the model generates or a customer writes in a prompt. A label that determines visibility should have a documented owner and a predictable format.

Do not put the customer's message into metadata merely to make it easier to search. That can undermine the purpose of restricting message fields. Prefer an internal identifier and keep the information needed to interpret it in an appropriately controlled system.

Also check the interaction with your masking configuration. If you remove all metadata before upload, do not assume a downstream policy can still evaluate a customer attribute that is no longer present. Agree which fields are permitted and necessary before deploying either change.

## Test permissions with two customers and two readers

Here is the small validation exercise I would run before rollout. It is a proposed test plan, not a report of hands-on results.

Create synthetic traces for Customer A and Customer B. Give each a distinct root identifier and obvious placeholder text. Include one trace with a missing identifier and another with a deliberately malformed value. Write down the expected visibility for every case before checking the result.

Use an engineering test account intended to see performance information, and a support test account intended to inspect only Customer A. Check that engineering can still answer the debugging question without seeing restricted content. Check that support can inspect the authorized case but cannot read Customer B's content.

Repeat the checks through whichever interfaces your team actually uses, including API-based readers if those are part of the workflow. Do not treat a screenshot of a hidden field as proof that every access path has been validated. Resolve unexpected results before adding real data.

## Make investigations temporary and specific

For an incident, I would record who needs additional visibility, which customer or traces are in scope, why access is needed and when it should be reviewed or removed. That is a team operating practice, not a claim that LangSmith automatically expires every grant.

The useful outcome is not simply more restrictive permissions. It is a debugging workflow where engineers can solve ordinary performance problems without unnecessary access, and exceptional investigations have a clear boundary. Decide what to collect first, then decide who can read what remains.

I'm Paras. I work at the intersection of AI, engineering and distribution.

I help AI teams explain production controls and developer workflows without losing the details that matter.

[Book a 30-minute call](https://cal.com/paras-madan/30min).
