Technology Deep-Dive

Our Tech

A purpose-built autonomous IT operations platform with specialized AI agents, deterministic guardrails, and enterprise-grade security.

Core Principle

Dex is not a chatbot wrapper around an LLM. It is a purpose-built autonomous IT operations platform that reasons through problems, executes operations safely, with the right permissions, under the right policies, with full auditability and transparency.

The Dex Platform at a Glance

Two specialized AI agents, a deterministic policy engine, enterprise-grade multi-tenant isolation, and deep integration with Microsoft 365, Google Workspace, Okta, and any SaaS platform.

What Makes Dex Different

Capability	Dex	Typical AI Tools
Autonomy	Autonomously execute IT operations end-to-end: reason, craft API calls, write scripts, troubleshoot like an L3 engineer	Suggest answers, link to KB articles
Guardrails	Deterministic policy engine with per-department overrides, approval workflows, and non-bypassable global safety rules - enforced at code level, not prompt level	Basic prompt instructions
Permissions	Delegated permissions - acts with the actual user's or admin's own permissions, never more	Application-level API keys with broad access
Learning	Persistent memory system that learns from every interaction and improves over time	Stateless - starts from scratch every time
Extensibility	On-the-fly app integrations - connect to any new SaaS platform mid-conversation using AI-generated code	Fixed integrations requiring vendor updates
Architecture	Per-organization isolated databases with dedicated encryption keys	Single-tenant or shared database
Integration	Native Microsoft Teams bot with real-time streaming, proactive messaging, and Slack (coming soon)	Web chat only

Autonomy

Dex

Autonomously execute IT operations end-to-end: reason, craft API calls, write scripts, troubleshoot like an L3 engineer

Typical AI Tools

Suggest answers, link to KB articles

Guardrails

Dex

Deterministic policy engine with per-department overrides, approval workflows, and non-bypassable global safety rules - enforced at code level, not prompt level

Typical AI Tools

Basic prompt instructions

Permissions

Dex

Delegated permissions - acts with the actual user's or admin's own permissions, never more

Typical AI Tools

Application-level API keys with broad access

Learning

Dex

Persistent memory system that learns from every interaction and improves over time

Typical AI Tools

Stateless - starts from scratch every time

Extensibility

Dex

On-the-fly app integrations - connect to any new SaaS platform mid-conversation using AI-generated code

Typical AI Tools

Fixed integrations requiring vendor updates

Architecture

Dex

Per-organization isolated databases with dedicated encryption keys

Typical AI Tools

Single-tenant or shared database

Integration

Dex

Native Microsoft Teams bot with real-time streaming, proactive messaging, and Slack (coming soon)

Typical AI Tools

Web chat only

Architecture Overview

Dex Platform Architecture

+----------------------------------------------------------------+
|                        DEX PLATFORM                            |
|                                                                |
|  +--------------------------+  +---------------------------+   |
|  |  DEX FOR END USERS       |  |  DEX COADMIN              |   |
|  |  (Resolver Agent)        |  |  (CoAdmin Agent)          |   |
|  |                          |  |                           |   |
|  |  "Solve 90% of IT        |  |  "Make every admin a      |   |
|  |   requests before a      |  |   10x admin"              |   |
|  |   ticket is opened"      |  |                           |   |
|  +--------------------------+  +---------------------------+   |
|          |          |                 |          |             |
|  +-------v----------v-----------------v----------v----------+  |
|  |             SHARED PLATFORM LAYER                        |  |
|  |                                                          |  |
|  |  +-----------------+ +-----------------+ +------------+  |  |
|  |  | Policy Engine   | | Reasoning Engine| | AI Engine  |  |  |
|  |  | (Deterministic  | | (Craft any API  | | (Multi-    |  |  |
|  |  |  Guardrails)    | |  call or script)| |  Provider) |  |  |
|  |  +-----------------+ +-----------------+ +------------+  |  |
|  |                                                          |  |
|  |  +-----------------+ +-----------------+ +------------+  |  |
|  |  | Skills &        | | Approval Engine | | Memory &   |  |  |
|  |  | Knowledge       | | (Human-in-the-  | | Learning   |  |  |
|  |  | System          | |  Loop)          | | System     |  |  |
|  |  +-----------------+ +-----------------+ +------------+  |  |
|  +----------------------------------------------------------+  |
|          |          |                 |          |             |
|  +-------v----------v-----------------v----------v----------+  |
|  |             INTEGRATION LAYER                            |  |
|  |                                                          |  |
|  |  MS Teams | Slack  | Web  | M365 Graph | Google          |  |
|  |  Bot      | (soon) | App  | API        | Workspace       |  |
|  |                                                          |  |
|  |  Okta | Any SaaS (via On-the-Fly Connections) | Devices  |  |
|  +----------------------------------------------------------+  |
|          |                                       |             |
|  +-------v---------------------------------------v----------+  |
|  |             DATA LAYER                                   |  |
|  |                                                          |  |
|  |  Per-Org Tenant Databases       Secure Key & Session     |  |
|  |  (Chats, Tasks, Policies,       Store (Tokens,           |  |
|  |   Devices, Knowledge,            Credentials,            |  |
|  |   Memories)                       Encryption Keys)       |  |
|  +----------------------------------------------------------+  |
+----------------------------------------------------------------+

Dex for End Users (Resolver Agent)

Mission: Autonomously resolve IT requests directly from Microsoft Teams or Slack — before a ticket is ever opened.

Target: 90% resolution rate.

How It Works

Identifies the user

Pulls their profile, department, job title, and device information from Microsoft Entra ID.

Evaluates policy

Checks the organization's structured policy to determine what this user is allowed to request and whether it requires approval.

Reasons and executes

Like an L3 engineer, reasons about the problem, constructs the right API calls, writes scripts if needed, and executes the solution.

Troubleshoots persistently

If something fails, reads the error, adjusts its approach, and tries again. Uses up to 40 reasoning steps per task.

Requests approval when needed

If policy requires it, identifies the right approvers from Entra security groups and waits for approval before proceeding.

Reports back

Confirms what was done, provides relevant details, and logs everything for audit.

Not a Chatbot — An Autonomous IT Engineer

The agent can construct any Microsoft Graph API call, write scripts to process data, run device diagnostics, and chain multiple operations together — all by reasoning about what needs to happen, not by following rigid scripts. When an API call returns an error, it reads the error message, identifies the issue, corrects its approach, and retries.

Example: SharePoint Access Issue

 Employee: "I can't open files in SharePoint"

 Dex Resolver (reasoning through the problem):
   Step 1: Query user's Entra profile and group memberships
   Step 2: Check which SharePoint sites the user should have access to
   Step 3: Verify the user's license includes SharePoint
   Step 4: Check for Conditional Access policies blocking access
   Step 5: Found it - user's license was removed during a bulk operation
   Step 6: Evaluate policy -> license assignment is auto_grant for this user
   Step 7: Craft Graph API call: POST /users/{id}/assignLicense
   Step 8: Confirm to user: "Your SharePoint license was missing.
           I've re-assigned it. Try again in a few minutes."

Key Capabilities

Identity & Access

Password resets, account unlocks, MFA resets, group membership changes, license assignments

Device Management

Real-time device diagnostics, disk analysis, cache cleaning, system information via secure device agent

Knowledge & Documentation

RAG-powered knowledge base search, web documentation lookup, skill-based resolution guides

Policy-Driven Access Requests

Evaluate eligibility, route approvals to the right team, grant access automatically when policy allows

Service Catalog

Employee onboarding workflows, equipment requests, software provisioning

Security Boundary: “Current User Only”

The Resolver Agent enforces a strict security principle: it can only perform operations that affect the requesting user. It cannot reset another user's password, view another user's devices, or modify another user's group membership. This is enforced at the guardrails level, not by prompt instructions.

Resolver Agent Flow

 Employee in Teams                  Dex Resolver Agent
 +---------------+   "Add me to    +-----------------------------+
 |               |    the Sales    | 1. Identify user from Entra |
 |  "Add me to   |    team"        | 2. Evaluate policy:         |
 |  the Sales    | --------------> |    - Target: "sales-team"   |
 |  team"        |                 |    - User eligible? YES     |
 |               |                 |    - Access rule: auto_grant|
 |               |  "Done! You've  | 3. Craft + execute Graph API|
 |               |   been added"   |    POST /groups/{id}/members|
 |               | <-------------- | 4. Confirm to user          |
 +---------------+                 +-----------------------------+

Dex CoAdmin (CoAdmin Agent)

Mission: Make every IT admin a 10x admin by autonomously executing complex administrative tasks across M365, Google Workspace, Okta, and any connected SaaS platform.

How It Works

Loads relevant skills

Checks its skill library for matching operational guides and best practices.

Plans the approach

Uses advanced reasoning (with extended thinking) to break down complex requests into executable steps.

Queries the environment

Reads current state via the admin's own API permissions (Graph API, Google Admin SDK, etc.).

Requests approval for changes

Before any modification (POST, PATCH, DELETE), shows the admin exactly what will be executed.

Executes with admin's permissions

Uses delegated tokens, not application permissions. Every action is performed as the admin.

Supports bulk operations

"Approve Always" rules let admins approve a pattern once and the agent executes the rest automatically.

Learns for next time

Saves key learnings to memory so future similar tasks are faster and more accurate.

The Delegated Permission Model

Most AI admin tools use application permissions — a single API key with broad access. Dex CoAdmin uses delegated permissions — the admin's own OAuth token, with the admin's own permission scope.

Traditional AI Admin Tool

-App Permission Key (Global Admin scope)
-Acts as "the app"
-Broad access
-Single audit trail
-Hard to revoke per-admin

Dex CoAdmin

+Admin's Own Token (Admin's own scope)
+Acts as the admin
+Scoped to admin's actual permissions
+Admin's audit trail
+Token expires, auto-revokes

Human-in-the-Loop Approval

Every mutating operation goes through an explicit approval flow. The “Approve Always” mechanism uses URL pattern matching — when an admin approves a pattern, any future operation matching that pattern is auto-approved for the duration of the task.

Approval Flow Example

 Admin: "Assign E5 licenses to all users in the Sales department"

 CoAdmin:
   1. GET /users?$filter=department eq 'Sales'  --> Found 47 users
   2. For each user:
      +-----------------------------------------------------+
      | APPROVAL REQUIRED                                   |
      |                                                     |
      | Operation: Assign License                           |
      | POST /users/{userId}/assignLicense                  |
      | Body: { "addLicenses": [{ "skuId": "..." }] }       |
      |                                                     |
      | [Approve Once] [Approve Always] [Deny/Dry-Run]      |
      +-----------------------------------------------------+

   Admin clicks "Approve Always" -->
   CoAdmin creates pattern rule: POST /users/*/assignLicense
   Remaining 46 users processed automatically

Multi-Platform Support

Platform	Integration Type	Capabilities
Microsoft 365	Delegated OAuth	Full Graph API - users, groups, licenses, Intune, SharePoint, Exchange, Teams
Google Workspace	Delegated OAuth	Admin SDK - users, groups, organizational units, Chrome devices
Okta	OAuth / API Token	User lifecycle, group management, application assignments
Any SaaS	On-the-fly connection	The agent creates integrations dynamically (see below)

Microsoft 365

Delegated OAuth

Full Graph API - users, groups, licenses, Intune, SharePoint, Exchange, Teams

Google Workspace

Delegated OAuth

Admin SDK - users, groups, organizational units, Chrome devices

Okta

OAuth / API Token

User lifecycle, group management, application assignments

Any SaaS

On-the-fly connection

The agent creates integrations dynamically

Sandboxed Script Execution

For complex data transformations (parsing CSVs, generating secure passwords, processing Excel files), CoAdmin includes an isolated secure container with access to crypto modules. HTTP access is restricted to read-only requests and no mutating API calls are allowed from scripts.

On-the-Fly App Integrations

One of Dex's most powerful capabilities: the agent can create integrations with new SaaS platforms mid-conversation, using AI-generated code. This means Dex's integration capabilities are unbounded — it can connect to any platform with a REST API.

Researches the API

Fetches the service's API documentation to understand endpoints, authentication, and capabilities.

Generates integration code

Writes code to handle the authentication flow (OAuth, API keys, client credentials, etc.).

Creates the connection

Registers the new integration with proper credential storage, API base URL, and tool configuration.

Collects credentials securely

Asks the admin for API keys or triggers an OAuth flow, with all credentials encrypted at rest.

Uses it immediately

A new API execution tool is injected into the current session, available right away.

Persists for future sessions

The integration is saved and automatically available in all future conversations.

Example: CrowdStrike Integration

 Admin: "Check our CrowdStrike alerts for compromised endpoints"

 CoAdmin:
   1. No CrowdStrike connection exists - loading Integration Builder skill
   2. Fetching CrowdStrike API documentation...
   3. Creating integration with OAuth2 client credentials flow
   4. "I need your CrowdStrike API credentials to connect."
      [Client ID: ________] [Client Secret: ________]
   5. Credentials saved (encrypted). Testing connection... Success!
   6. GET /alerts/queries/alerts/v2?filter=status:'new'
   7. "Found 3 new alerts: ..."

 Next week, the admin asks about CrowdStrike again ->
 Integration auto-loads, no setup needed.

Skills: Specialized Operational Knowledge

Skills are domain-specific knowledge modules that give agents expert-level understanding of specific IT workflows, API patterns, and best practices. Each skill maps to specific use cases and contains step-by-step procedures, API endpoint recipes, permission requirements, and edge case handling.

Built-In Skills

Skill	Use Cases	What It Provides
Admin Operations	Password reset, account lifecycle, bulk provisioning, group management	Authentication Methods API recipes, bulk user creation workflows, group membership patterns
Governance & Optimization	License analysis, stale Teams cleanup, orphaned storage, SharePoint governance	Report API endpoints, optimization queries, cost-saving analysis patterns
Security & Device	Account compromise response, sign-in monitoring, Intune actions, BitLocker recovery	Incident response procedures, audit log queries, device management commands
Troubleshooting	Sign-in failures, access denied errors, device performance issues	Diagnostic workflows, Conditional Access analysis, Intune compliance checks
Integration Builder	Connect to third-party services, create custom API integrations	Templates for OAuth/credential auth, API discovery patterns, integration creation workflows

Admin Operations

Use Cases

Password reset, account lifecycle, bulk provisioning, group management

Provides

Authentication Methods API recipes, bulk user creation workflows, group membership patterns

Governance & Optimization

Use Cases

License analysis, stale Teams cleanup, orphaned storage, SharePoint governance

Provides

Report API endpoints, optimization queries, cost-saving analysis patterns

Security & Device

Use Cases

Account compromise response, sign-in monitoring, Intune actions, BitLocker recovery

Provides

Incident response procedures, audit log queries, device management commands

Troubleshooting

Use Cases

Sign-in failures, access denied errors, device performance issues

Provides

Diagnostic workflows, Conditional Access analysis, Intune compliance checks

Integration Builder

Use Cases

Connect to third-party services, create custom API integrations

Provides

Templates for OAuth/credential auth, API discovery patterns, integration creation workflows

Skill Loading Flow

 Admin: "Reset password for John"
              |
              v
 Agent checks available skills
 --> "password reset" matches Admin Operations Skill
              |
              v
 Agent loads skill -> Receives full operational guide:
   - Use Authentication Methods API (not passwordProfile) for admin accounts
   - Required permission: UserAuthenticationMethod.ReadWrite.All
   - Step 1: Verify user exists, Step 2: Check if privileged account...
              |
              v
 Agent executes with expert-level knowledge

Custom Skills

Admins can create their own skills that persist across sessions. When an admin develops a workflow for their specific environment, they can save it as a custom skill that automatically loads whenever a future request matches.

Memory: Agents That Learn

Dex agents have a persistent memory system that learns from every interaction and gets smarter over time. After completing tasks, the agent saves key learnings — specific API behaviors, user preferences, environment quirks, and solutions to problems.

Memory in Action

 Session 1:
   Admin: "Reset MFA for admin account fails"
   Agent tries standard approach -> 403 error
   Agent discovers: Privileged accounts need different API
   Agent solves the issue
   Agent saves memory: "For privileged accounts, use Authentication Methods API
                        with UserAuthenticationMethod.ReadWrite.All scope"

 Session 2 (days later):
   Admin: "Reset MFA for another admin"
   Agent loads memories -> sees the learning from Session 1
   Agent uses the correct API on the first try
   --> Faster resolution, no wasted iterations

What Gets Remembered

API Behaviors

Which endpoints work for which scenarios, required permissions, error workarounds

Environment Patterns

Naming conventions, group structures, license SKU IDs

User Preferences

Preferred output formats, common targets, frequently used operations

Recurring Solutions

Workarounds, alternative approaches, edge cases

Per-userPrioritizedManageableCategory-organizedAuto-deduplicated

The Policy Engine: Deterministic Guardrails

Unlike most AI tools that rely on prompt instructions for safety, Dex implements a deterministic, code-level policy engine that evaluates every action against structured policy rules before execution.

Policy Evaluation Flow

 +------------------------------------------------------------+
 |                   POLICY EVALUATION                          |
 |                                                              |
 |  User Request                                                |
 |       |                                                      |
 |       v                                                      |
 |  +-------------+   +--------------+   +----------------+     |
 |  | Global      |   | Tenant       |   | Department     |     |
 |  | Policy      |-->| Policy       |-->| Overrides      |     |
 |  | (Hardcoded) |   | (Org Config) |   | (Per-Dept)     |     |
 |  +-------------+   +--------------+   +----------------+     |
 |       |                   |                   |              |
 |       v                   v                   v              |
 |  +--------------------------------------------------------+  |
 |  |             POLICY DECISION                            |  |
 |  |                                                        |  |
 |  |  auto_grant --------> Execute immediately              |  |
 |  |  require_approval --> Route to approver group          |  |
 |  |  prohibited --------> Block with explanation           |  |
 |  |  not_configured ----> Escalate to human                |  |
 |  +--------------------------------------------------------+  |
 +--------------------------------------------------------------+

Six-Layer Policy Model

Global Policy

Non-negotiable, hardcoded

•Never bypass MFA or Conditional Access
•Never grant admin roles directly
•Never reveal passwords, tokens, or secrets
•Never perform destructive operations without explicit approval

Tenant Policy Configuration

Per-organization defaults

•Default approval requirements
•Maximum access durations
•MFA requirements for sensitive operations

Target Rules

Per-resource/service

•Define what resources exist (Entra groups, Teams, SharePoint sites, licenses)
•Set access rules per target: auto-grant, require approval, or prohibited
•Define user eligibility by department, job title, or employee type

Department Policies

Per-department overrides

•Contractors get shorter access durations and stricter approval requirements
•Engineering gets auto-grant to developer tools
•Each department can have different rules for the same resource

Action Policies

Identity/security operations

•Password reset: self-only, no approval needed
•MFA reset: self-only, requires security team approval
•Account unlock: self-only, auto-grant

Runtime Guardrails

Pre-execution safety checks

•Validates every API call before execution
•Blocks prohibited operations at the code level
•Enforces "current user only" boundary for the Resolver Agent
•Cannot be bypassed by prompt injection or LLM hallucination

Key Design Principle

The policy engine is deterministic — the same input always produces the same decision. The AI agent cannot override, reinterpret, or circumvent policy decisions. If the policy says “prohibited”, the API call is blocked at the code level before it reaches any external service.

Modular App System

Dex uses a modular app architecture to control which features, tools, and policies are available per organization. Think of it as an app store for IT capabilities. Organizations enable only the apps they need — disabled apps become invisible to the agent.

App System

 +--------------------------------------------------+
 |                DEX APP SYSTEM                    |
 |                                                  |
 | +---------+ +---------+ +---------+ +--------+   |
 | | Entra   | | Share-  | |Exchange | | Intune |   |
 | | ID      | | Point   | | Online  | |        |   |
 | |         | |         | |         | |        |   |
 | | Skills  | | Skills  | | Skills  | | Skills |   |
 | | Targets | | Targets | | Targets | | Tools  |   |
 | | Actions | | Tools   | | Tools   | |        |   |
 | +---------+ +---------+ +---------+ +--------+   |
 |                                                  |
 | Enable/Disable per organization                  |
 | OR logic: item enabled if ANY parent app on      |
 +--------------------------------------------------+

Skills

Domain-specific knowledge and resolution guides

Policy Targets

Resources that can be managed

Policy Actions

Operations that can be performed

Connections

API credentials and OAuth configurations

Multi-Tenant Architecture

Every organization gets complete data isolation through a dedicated database. No shared tables between organizations for operational data.

Tenant Isolation

 +-------------------------------------------------------+
 | PLATFORM LAYER                                        |
 | Organizations | Users | Billing | Enrollment Tokens   |
 +---------------------------+---------------------------+
                             |
         +-------------------+-------------------+
         |                   |                   |
 +-------v-------+  +-------v-------+  +--------v------+
 |  Contoso      |  |  Acme Corp    |  |  Globex Inc   |
 |               |  |               |  |               |
 | Chats         |  | Chats         |  | Chats         |
 | Tasks         |  | Tasks         |  | Tasks         |
 | Policies      |  | Policies      |  | Policies      |
 | Devices       |  | Devices       |  | Devices       |
 | Knowledge     |  | Knowledge     |  | Knowledge     |
 | Memories      |  | Memories      |  | Memories      |
 | Usage Logs    |  | Usage Logs    |  | Usage Logs    |
 +---------------+  +---------------+  +---------------+

No shared tables between organizations for operational data

Per-org encryption keys for credential storage

Isolated database connections with configurable read replicas

Secure session management with scoped isolation between tenants

AI Engine

Dex doesn't lock into a single AI provider. The platform includes an AI provider abstraction layer that supports leading foundation models — with the flexibility to add new providers as the landscape evolves.

Three-Tier Model Selection

MINI

Fast + Efficient

Planning, simple questions, coordination

GPT

Balanced

Multi-step reasoning, API orchestration

CODE

Most Capable

Complex coding, PowerShell, advanced analysis

The agent can dynamically switch models mid-task based on complexity. For complex problems, agents use extended thinking — additional reasoning tokens to think through the problem deeply before acting.

Agentic Execution Loop

Up to 40 Steps Per Task

 +---------------------------------------------------------+
 |                 AGENTIC REASONING LOOP                  |
 |                                                         |
 |  1. Build context (user, policies, skills, memory)      |
 |  2. LLM reasons (with extended thinking)                |
 |  3. Agent crafts the right action:                      |
 |     - Construct an API call with the right filters      |
 |     - Write a script for data transformation            |
 |     - Load a skill for domain expertise                 |
 |     - Ask the user for clarification                    |
 |  4. Execute with guardrails:                            |
 |     a. Validate against policy engine (code-level)      |
 |     b. Check approval status (if mutating operation)    |
 |     c. Execute the action                               |
 |     d. Log result for audit                             |
 |  5. Evaluate results - if error, adjust and retry       |
 |  6. Repeat until resolved                               |
 |                                                         |
 |  The agent does NOT give up on errors.                  |
 |  It reads error messages, adjusts its approach,         |
 |  tries alternative endpoints, and persists              |
 |  like an experienced L3 engineer.                       |
 +---------------------------------------------------------+

Task Transparency: Full Visibility Into Agent Reasoning

Every task Dex performs is fully transparent. The product provides detailed task views showing exactly what the agent did and why — not just logging, but a complete, human-readable timeline of the agent's work.

Every reasoning step

Every API call

Every tool invocation

Every policy decision

Every approval

Thinking traces

Task Trace Example

 Task: "Assign E5 license to all Sales users"
 +-------------------------------------------------------+
 | Step 1: Thinking                                      |
 | "I need to find all users in the Sales department,    |
 |  then assign E5 licenses. Let me query users..."      |
 +-------------------------------------------------------+
 | Step 2: API Call                                      |
 | GET /users?$filter=department eq 'Sales'              |
 | --> 200 OK, 47 users returned                         |
 +-------------------------------------------------------+
 | Step 3: API Call                                      |
 | GET /subscribedSkus?$select=skuId,skuPartNumber       |
 | --> Found E5 SKU: 06ebc4ee-...                        |
 +-------------------------------------------------------+
 | Step 4: Approval Request                              |
 | "Assign Microsoft 365 E5 to 47 users in Sales"        |
 | --> Admin approved with "Approve Always" pattern      |
 +-------------------------------------------------------+
 | Steps 5-51: Execution (auto-approved)                 |
 | POST /users/{id}/assignLicense for each user          |
 | --> 47/47 successful                                  |
 +-------------------------------------------------------+
 | Step 52: Memory Saved                                 |
 | "E5 SKU ID for this tenant: 06ebc4ee-..."             |
 +-------------------------------------------------------+

Integration: Microsoft Teams

Dex lives where your employees already work — inside Microsoft Teams.

Real-Time Streaming

Unlike chatbots that make you wait for a complete response, Dex streams its response in real-time. As the agent thinks, queries APIs, and executes operations, the message updates live in Teams.

Proactive Messaging

Dex can proactively reach out: notify approvers, alert users when requests are processed, send status updates for long-running operations, and deliver scheduled reports.

Teams Architecture

 MS Teams                       Dex Platform
 +------------+                +---------------------+
 | User sends |   Webhook      | Token Validation    |
 | message    | -------------> | (Secure JWKS)       |
 |            |                |        |            |
 |            |                | Route to Org        |
 |            |                | (per-tenant webhook)|
 |            |                |        |            |
 |            |   Streaming    | Resolver Agent      |
 | Real-time  | <------------- | (reasoning loop)    |
 | updates    |                |        |            |
 |            |                | Final response      |
 | Final      | <------------- |                     |
 | answer     |                +---------------------+
 +------------+

Per-tenant webhook URLs

Each organization gets a unique endpoint

Cryptographic token validation

Every incoming message is verified

Session continuity

Conversation state preserved for multi-turn interactions

Copilot agent support

Compatible with Microsoft 365 Copilot extensibility

Security & Compliance

Defense in depth — seven layers of security from network to audit.

Network Security

+Rate limiting (multi-tier: public, authenticated, strict)
+Cryptographic token validation
+CORS with configurable origins

Authentication

+Microsoft Entra ID integration
+OAuth 2.0 with PKCE for provider connections
+Secure session management with expiration

Authorization

+Delegated permissions (user's own scope)
+Role-based access (admin vs. end-user)
+App-level feature gating per organization

Policy Engine

+Deterministic structured guardrails
+Non-bypassable global safety rules
+Per-department policy overrides

Runtime Guardrails

+Pre-execution validation (code-level)
+"Current user only" enforcement
+Prohibited operation blocking

Data Isolation

+Per-org isolated databases
+Per-org encryption keys
+Scoped session and credential isolation

Audit & Transparency

+Full operation logging (every API call)
+Detailed task traces (every reasoning step)
+M365 audit trail (delegated identity)

Key Security Properties

No Standing Privileges

CoAdmin uses time-limited delegated tokens that expire. No persistent API keys with broad access.

Prompt Injection Resistance

Safety is enforced at the code level (guardrails), not by prompt instructions. Even if the LLM is tricked, the execution layer blocks prohibited operations.

Credential Isolation

Sensitive data (passwords, tokens) encrypted with per-org keys. Credentials are never logged or exposed.

Audit Everything

Every API call, script execution, approval decision, and policy evaluation is logged with user identity, timestamp, and full request/response details.

What's Included

Dex for End Users

Microsoft Teams bot (native integration with real-time streaming)
Autonomous IT agent that reasons and solves problems like an L3 engineer
Persistent troubleshooting - up to 40 reasoning steps per task, never gives up on the first error
Policy engine with department overrides and automatic approval routing
Device management with real-time diagnostics
Knowledge base with RAG-powered search
Service catalog for common requests
Full audit trail with detailed task transparency

Dex CoAdmin

Web-based admin console
Multi-platform admin agent (M365, Google, Okta, any SaaS)
Delegated permission model (admin's own credentials, admin's own audit trail)
Human-in-the-loop with "Approve Always" patterns for bulk operations
On-the-fly app integrations with AI-generated code
Skills library with built-in and custom operational guides
Memory system that learns from every interaction
Sandboxed script execution (PDF, Excel, Word, CSV parsing)
Full task transparency with every reasoning step visible

Platform

Multi-tenant isolated architecture (per-org databases)
Multi-provider AI engine with dynamic model switching
Extended thinking for complex reasoning
Modular app system (enable only what you need)
Detailed task traces with step-by-step transparency
Enterprise-grade encryption and security
REST API for custom integrations

Ready to see Dex in action?