# User Augmentation: giving every employee agents, without losing control

> You buy the front end. What makes the difference is the governance of the agents it exposes: who can do what, with which data, and at what cost.

Source : https://dasein-ai.com/en/articles/user-augmentation · Dasein · Updated 1 October 2026

## In short

- Companies usually buy a ready-made AI front end rather than build one.
- That front end exposes agents to employees: this is where governance is needed.
- Dasein helps put that governance in place: declarative agents, controlled MCP connections, identity, rights, skills and managed model calls.

## 1. The starting point: you buy a front end

A “front end” is the interface where employees talk to AI: a chat window, a list of assistants, documents to attach. This market is mature: there are solid sovereign, open-source and SaaS options. Rebuilding one makes no sense.

| Solution | Type | Key point |
| --- | --- | --- |
| Prisme.ai | French platform, SaaS or self-hosted | No-code agent builder, governance, per-team rebilling |
| Open WebUI | Open source, self-hosted | ChatGPT-style interface, groups, SSO, MCP tools |
| LibreChat | Open source (MIT), self-hosted | Multi-model, agents, agent catalogue, usage tracking |
| Mistral Le Chat Enterprise | SaaS or self-hosted | Sovereign assistant, MCP connectors, on-behalf-of authentication |
| Microsoft 365 Copilot | SaaS | Declarative agents described in a manifest, inside Microsoft 365 |
| ChatGPT, Claude, Gemini Enterprise | SaaS | Admin-managed MCP connectors, audit, group-based rights |
| Dust, Langdock | SaaS | Team agent spaces, action approval, SSO |

*Open WebUI, an open-source self-hosted front end. Screenshot: Open WebUI project (Open WebUI licence).*

> The choice of front end matters less than what sits behind it. The same front end can be a gadget or a production tool: it all depends on the governance of the agents it exposes.

## 2. The real topic: governing the agents you expose

The front end offers agents to employees: a summary assistant, a document search assistant, a writing assistant. Each of them reads data, calls tools and consumes models. Without rules, you quickly get agents that see too much, costs that drift and no record of what happened.

*Diagram: The governance chain: the user, their assistant, the gateway and the systems, with checks at each step.*

## 3. The building blocks, one by one

- **Declarative agents** : An agent is described in a file (YAML) rather than coded: its role, instructions, model, tools and who may use it. It can be reviewed, versioned and approved before publication, like any configuration.
- **MCP connections** : MCP (Model Context Protocol) is the standard that lets an agent use tools: read tickets, search a document base, query a CRM. Each tool is exposed by an “MCP server”.
- **Governing MCP connections** : Not all MCP servers are equal. You keep a catalogue of approved servers, decide which groups may use them, and separate read tools from tools that write into a system.
- **Identity propagation** : The agent acts with the identity of the person using it. When it queries a tool, it only sees what that person is allowed to see. This is the default for any personal or sensitive data.
- **Machine to machine** : For some tools, the agent connects with a service account, without going through the user: an internal document base open to all, a read-only reference. Simpler, but only for data everyone may see.
- **Rights delegation** : The user delegates only part of their rights to the agent: read but not change, on a precise scope, for a limited time, revocable at any moment.
- **Skills and prompts** : A skill is reusable know-how: a folder with instructions, document templates and possibly scripts. The agent only loads it when needed. Prompts are managed as a shared, versioned library.
- **Managing LLM calls** : Every model call goes through a gateway: model choice per need, quotas per team, cost tracking, logging. You can change models without touching the agents.

Simplified example: an agent described in YAML, with one identity-propagation connection and one machine-to-machine connection.

```
agent: incident-summary
description: Summarises an incident and drafts a resolution note
model: mistral-large             # call routed through the LLM gateway
instructions: prompts/incident-summary.md
skills:
  - write-resolution-note
tools:
  - mcp: servicenow
    auth: identity-propagation   # acts with the user’s own rights
    scopes: [incident.read]
  - mcp: document-base
    auth: machine-to-machine     # service account, read only
    scopes: [documents.read]
access:
  groups: [support-l2]
human-approval:
  required-for: [write]
```

## 4. Identity propagation or machine to machine?

This is the most structuring decision. MCP relies on OAuth 2.1 and defines two official extensions that match these two modes exactly.

|  | Identity propagation | Machine to machine |
| --- | --- | --- |
| The agent acts… | on behalf of the user | with a service account |
| What it sees | only what the user may see | everything the service account may see |
| Controlled by | the corporate directory (groups, roles, conditional access) | the service account’s scope |
| Use it for | email, tickets, CRM, personal data | references and documentation open to all |
| In MCP | “Enterprise-Managed Authorization” extension | “Client Credentials” extension |

## 5. What we almost always add

- Single sign-on (SSO) and directory group sync, to give access to agents by team.
- A catalogue of agents and connectors, with approval before anything is published.
- An audit log: who used which agent, which tool, with which data.
- Human approval for sensitive actions, such as any write into a system.
- Adoption and cost tracking per team, with rebilling if needed.
- Knowledge bases that respect the original access rights.
- Guardrails against sensitive data leaks.
- Agent versions and evaluation before every update.

## 6. Where to start

- Choose the front end for your constraints: sovereignty, hosting, tools already in place.
- Start with three useful agents, on a narrow scope, for a pilot group.
- Connect two or three MCP servers, deciding for each: identity propagation or machine to machine.
- Route every model call through the gateway from day one.
- Measure usage and feedback, then widen the catalogue.

## Further reading

- [Prisme.ai: product overview](https://docs.prisme.ai/products/overview)
- [Open WebUI](https://github.com/open-webui/open-webui)
- [LibreChat](https://github.com/danny-avila/LibreChat)
- [Mistral: Le Chat Enterprise](https://mistral.ai/news/le-chat-enterprise/)
- [Microsoft: declarative agent manifest](https://learn.microsoft.com/en-us/microsoft-365-copilot/extensibility/declarative-agent-manifest-1.6)
- [MCP: authorization specification](https://modelcontextprotocol.io/specification/draft/basic/authorization)
- [MCP: Enterprise-Managed Authorization](https://modelcontextprotocol.io/extensions/auth/enterprise-managed-authorization)
- [Anthropic: Agent Skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)
- [Claude: organisation-wide MCP connectors](https://support.claude.com/en/articles/15537633-authorize-mcp-connectors-for-your-entire-organization)
- [OpenAI: MCP apps in ChatGPT](https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt)
