Give product and internal agents distinct identities.
Product copilots and internal automations stop sharing service accounts; each is a principal you can reason about and revoke.
Add governed agent identity and permissions to products, internal tools, and developer workflows.
Technology companies are adding agents to products while also deploying internal agents for engineering, support, sales, and operations. Product teams must determine how an agent acts within each customer tenant, on behalf of each user, and across connected applications.
Example tenants. The boundaries, roles and grants are the ones you set.
Product copilots and internal automations stop sharing service accounts; each is a principal you can reason about and revoke.
Boundaries are enforced at the tool-call layer, so a multi-tenant product agent cannot cross tenants even if application logic slips.
The agent acting for a user inherits that user’s permissions inside their tenant — no more, even when asked.
Enterprise customers choose which actions your agent may take for each of their users, and the agent is capped at the smaller of that grant and the user’s own permissions.
An action your customer did not grant never reaches the tool list your agent is handed, so the step stays in a person’s hands inside your product’s own experience.
Customer-connected integrations run on credentials Fabriq holds and limits, so your product never stores them raw.
Per-tenant activity logs give your customers the audit story their security teams demand.
Swap models or frameworks without re-answering the enterprise security questionnaire — controls live in the layer, not the stack.
Explore the context attached to every request.
customer-agent has a defined purpose and a bounded set of tools.
The request acts for customer user, using that person’s permissions.
The policy applies to the requested action within Tenant workspace, before the tool executes.
Copilots act within each tenant under the end user’s own permissions, and reach only the actions that tenant granted.
Engineering agents are granted branches and pull requests; merge and deploy are not in the list they receive, so those stay with an engineer.
Support agents resolve within the customer’s account using the actions the rep they assist already holds; anything past that is refused and lands with a person.
Operations agents read production context freely; changing infrastructure is not an action they hold, so the on-call engineer makes it.
Customer-connected apps run on credentials Fabriq holds, rotates, and revokes centrally.
Assistants answer from approved sources under each employee’s permissions — internal data stays limited by role.
As a layer between your agents and tenant data — not a rearchitecture. Your product keeps its stack, model, and framework; agent tool calls route through Fabriq, which resolves tenant, workspace, and user boundaries on every request.
Isolation is enforced at the tool-call layer with the tenant, workspace, and acting user in every authorization decision. Even a bug or manipulated prompt in the agent cannot cross tenants, because the boundary sits outside the model and the application code.
Disconnecting kills the connection’s token immediately, and session revocation takes effect now — per user, without touching other tenants.
Yes. Each enterprise tenant sets its own grant for your agent, and the agent is capped at the intersection of that grant and the acting end user’s own permissions inside the tenant — your customers choose what agents can access and do for each of their users.
You provision users and call the API; Fabriq handles per-user OAuth, token storage, scoping, and the audit trail underneath your product.
Every agent action in your product carries the end-user identity and the verdict — evidence your enterprise customers can query when they ask what the agent did.