Agent governance starts with identity: the week agents became employees on paper
LangChain, Oak, and Weaviate all landed on the same answer this week: agents need identities, permissioned tool access, and a record of every step.
- LangSmith Tool Gateway, now in public beta, manages credentials, identity, and access for agent tool calls, with approval policies for human-in-the-loop confirmation of sensitive calls. Self-reported m:…9103
- LangChain argues observability is the cornerstone of governance because guardrails do not guarantee compliance, and reports 87% of teams deploying agents on LangSmith had tracing in place before their first production deployment. Self-reported m:…6109
- Oak governs AI agents by treating them as identities in an existing identity graph, in four steps — Know, Own, Right-size, Control — with a single inventory including shadow agents and a human owner for every agent. Self-reported m:…9634
- Weaviate reports that providing Markdown versions of its documentation reduced token use on page loads by about 20%, and that in one test an agent took 23 turns with hidden code against 6 turns with Markdown. Self-reported m:…9849
The gateway in the middle
LangChain has introduced LangSmith Tool Gateway, a managed layer that sits between agents and the tools they call, and it is now in public beta. The platform centralises credential management, identity resolution, and access control, so engineering teams can grant agents access to tools without hand-rolling authentication for each one. Admins can define specific tool kits, set deny policies at the org or workspace level, and require human-in-the-loop approval for sensitive tool calls. It also provides end-to-end visibility into tool calls, including which servers were used, by whom, with what outcomes, and at what latency, and its audit logs capture which tool ran and as whom across the organisation. That last detail is the point: when an agent does something, someone should be able to say who it acted as. m:…9103
The design choices show how LangChain expects agents to be used in practice. The gateway supports acting as the user, using individual credentials through identity providers like Okta or Entra ID, or acting as the agent, using shared credentials via profiles. That search mode connects directly to the problem Google is also addressing with Tool Retrieval in the Gemini API: tool libraries have grown past the point where handing an agent everything is sensible. The gateway is the control layer for that world, and the search mode is the admission that the library itself needs managing. m:…9103
Why observability comes first
LangChain's companion argument, published alongside the gateway, is that governance starts with observability, and it is worth taking seriously because it cuts against the usual sales pitch. The claim is that guardrails do not guarantee agent compliance, so recording and analysing every step an agent takes is the cornerstone of governance. Centralised tracing, in this view, is an audit trail that regulators and security teams can use to confirm guardrails are actually in place, and to detect when agents game their way around a limit, for example by bypassing refund limits. Governing bodies like OWASP, NIST, and the EU provide guidance on agent risks, LangChain notes, but do not define mitigation or verification methods, which leaves teams to build the verification themselves. m:…6109
The framework splits governance into two halves that feed each other. Preventative governance covers pre-production testing and runtime guardrails, while detective governance covers production monitoring: online evaluations, alerts, pattern recognition, and regression detection. Failures found in production are meant to feed back into prevention, turning into tighter guardrails or new regression tests. LangChain reports that 87% of teams deploying agents on LangSmith had tracing in place before their first production deployment, and describes LangSmith Insights, which clusters trace data into common behaviours and failure modes. This suggests the trace is becoming the unit of governance, the way the log line once was. m:…6109
Agents as identities
Oak, an identity security company, makes the same argument from the identity side rather than the observability side. Its framework treats AI agents as identities inside an enterprise's existing identity graph, governed the same way as human users and service accounts, and it has four steps: Know, Own, Right-size, and Control. Know means a single inventory of all agents across platforms, including shadow agents that no central team approved. Own means every agent is tied to an accountable human owner. Right-size means least-privilege access, with the system identifying and removing unused permissions based on activity. Control means policy-based enforcement over the tools agents call. Oak says it integrates with existing agent platforms like Copilot Studio, Bedrock, Agentforce, and n8n without requiring agents to be rebuilt or moved, and that it logs every action an agent takes for audit purposes. m:…9634
The practical appeal of Oak's approach is that it reuses machinery companies already have. Identity governance is a solved problem in the sense that enterprises already run it for people; the question is whether the same machinery stretches to software that acts on its own. Oak's answer is that the activity-based identity graph already covers people and service accounts, so agents slot into it. The unresolved question is whether an agent's permissions can really be right-sized by watching what it did yesterday, when tomorrow's task may legitimately need something it has never touched. Least privilege is easy to state and hard to keep true for a general-purpose worker. m:…9634
The developer-experience half
Weaviate adds the half of this story that governance teams usually miss: agents are also readers, and they read badly when the material is built for humans. The company says it watched coding agents use its documentation by running tasks in a repeatable way and analysing logs, and found that agents often drew incorrect conclusions from incomplete pages. Some pages were truncated or missing code examples for specific languages, fetch tools in different coding environments returned different parts of a page, and an outdated sentence on a concepts page caused agents to use an older client library. m:…9849
The fixes were unglamorous and effective, which is the lesson. Weaviate says providing Markdown versions of documentation reduced token use on page loads by about 20%, and that after the changes, fetch tools returned correct snippets in every checked run. In one test, an agent took 23 turns to solve a task with hidden code, against 6 turns with Markdown. This suggests the governance conversation and the developer-experience conversation are the same conversation: an agent that cannot read your documentation correctly will also not follow your policies correctly, and the cheapest control may be making the instructions legible in the first place. m:…9849
What is still unresolved
- Whether right-sizing agent permissions from past activity holds up when an agent takes on a genuinely new task
- How many teams actually review agent traces and audit logs, rather than merely collecting them
- Whether gateway and identity layers from different vendors will interoperate, or lock teams into one stack
Provenance by Synorb. Every claim links to its source. This story was written by an agent from the Manifests listed below. Read the methodology and limitations, or send a correction.
Free to reuse, including commercially. Credit “Hanging Context, with provenance by Synorb” and link to this story. Keep the cited Manifest ids. Reuse terms v1.