← Plugin catalog
Developer Tools

Dtwo

Dtwo v1.3.5

Policy for agent tool calls

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Create MCP gateways and configure their authentication
  • Add and edit the MCP servers behind a gateway
  • Write and validate Rego policies for tool calls and responses

Cost & access

This plugin does not process payments.

Declared limitations

  • The user pastes a secret into the chat. The plugin must not pass it to any tool. It should tell the user not to share secrets in the chat and give them the Dtwo Vault link to enter it there instead.
  • A bulk destructive request. The plugin must not delete anything without confirmation. It should list the policies and ask the user to confirm which ones to delete.
  • A Rego request that has nothing to do with Dtwo gateways. The plugin should not be used: it is general OPA work for Kubernetes, so no Dtwo tools are called and the assistant answers on its own.

Onboarding example

Set up my first Dtwo gateway.
Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 16, 2026. Package observed Nov 16, 2026.

View package source →

Description

From the marketplace listing

Dtwo is the security control plane for agents. This plugin connects Codex to your Dtwo account, so you can run your MCP gateways from the conversation. Create a gateway, set how clients authenticate to it, and add the MCP servers your agents use. Write a policy in Rego, validate it, and attach it to the gateway's ingress pipeline, which runs before a tool call, or its egress pipeline, which runs on the response. Publish a version, deploy it, and roll back to an earlier version if you need to. Search recent gateway events to see what each policy decided. Skills cover gateway configuration, the policy lifecycle, and Rego authoring, plus a guided setup for your first gateway. They ask before deploying to a running gateway or deleting a policy. The plugin acts only inside the Dtwo organization you sign in to. You need a Dtwo account.

Language: English · Automatically detected from descriptions.

Matches for “agentic-security”

Exact text from the indicated source. A mention alone does not establish support for your task.

Publisher keywords · listing

mcp mcp-gateway policy-as-code rego opa agentic-security governance guardrails

Changes

No changes recorded yet. Follow this plugin to keep track of future changes.

First seen Nov 16, 2026. Last seen Nov 16, 2026.

Keywords

Files & skills

File archives

Plugin package14 files · 131 KBBrowse files →
Skill instructions
dtwo-end-user-guide27.4 KB

View saved version →

---
name: dtwo-end-user-guide
description: |
  Produce a short PDF — one page whenever the content fits — that an administrator forwards to their END
  USERS, telling those users what systems an existing Dtwo gateway reaches and how to connect their own AI
  client to it. Tailored to one client (Claude
  Code, Claude Desktop, Cursor, Codex) and to whether the organization has already configured that client
  centrally. This documents a gateway for the people who will use it — it does not build or change one.
  TRIGGER when: user wants something to hand to their users — "a guide I can send the team", "instructions for
  my users", "how do people connect to this", an end-user one-pager, handout, or rollout doc for a gateway.
  SKIP when: the user is creating, configuring or deploying a gateway themselves (use setup for a first
  gateway, dtwo-gateway-config for YAML and MCP server entries); attaching or publishing policies (use
  dtwo-gateway-policy); writing Rego (use dtwo-policy-rego).
---

<!-- © 2026 Dtwo, Inc. -->

# Dtwo End-User Guide

You produce a short PDF an administrator forwards to their colleagues — one page when the content fits, two
when the gateway is large. It tells those colleagues what
systems their AI assistant can now reach through an existing Dtwo gateway, and exactly how to connect their
own client to it.

**The reader is not the administrator.** The person running this skill already has a gateway; the person
holding the output is someone who just needs to use it. Write for a non-technical colleague who has never
heard of MCP. Nothing in the document tells anyone how to create or configure a gateway.

## Companion skills

- **dtwo-gateway-config** — load when the user wants to change what's behind the gateway before documenting it.
- **setup** — the admin-facing counterpart. If the user has no gateway yet, they want that skill, not this one.

## Voice

- Plain and direct. No marketing language, no superlatives, no "unlock", "seamless", "empower".
- **Never call Dtwo a "gateway" in the document.** That word is internal. To end users it is a connection, or just Dtwo.
- Value first, mechanism second. Say what the reader can now do, not how routing works.
- Short sentences. Contractions are fine.

## Step 1 — Pick the gateway

Call `dtwo-list-gateways`. Show the user the gateways by name and ask which one the document is for.

If the Dtwo MCP server is not connected, say so and stop — the document cannot be built without the gateway's
real server list. Never invent connected systems.

## Step 2 — Read the gateway configuration

From the chosen gateway's `configuration` YAML, extract:

- `url` — the MCP endpoint users connect to.
- `mcp_servers[].name` — the connected systems. These drive the whole first section.
- The auth mode, which decides the sign-in wording:
  - `jwks_info.jwt_issuer` is a Dtwo Auth0 tenant (`*-dtwo.us.auth0.com`) → **dtwo** → "sign in with your Dtwo account"
  - any other issuer (Okta, Entra, etc.) → **custom** → "sign in with your organization's identity provider"
  - `authentication.enabled: false` → **none** → "This connection doesn't ask for a sign-in, so it connects straight away."

Derive the MCP server name used in commands and config as the kebab-cased gateway name (`Acme Prod` →
`acme-prod`), falling back to `dtwo-gateway` if unnamed. For Claude Desktop's connector name, prefer something
a person would recognize — `Dtwo` unless the user says otherwise.

**Filter out non-work servers.** Gateways often carry development scaffolding a colleague would not recognize:
echo servers, pass-through-auth dev entries, anything on `host.docker.internal` or `localhost` with a name like
`echo`, `test`, `probe`, `my-*-mcp`. Propose leaving those off the page and confirm, rather than listing them
beside Salesforce and Slack.

## Step 3 — Pick the AI client

Ask which client the instructions are for: **Claude Code**, **Claude Desktop**, **Cursor**, or **Codex**.

The answer names the document — 

Preview of the first 4,000 characters. Read full instructions →

dtwo-gateway-config57.6 KB

View saved version →

---
name: dtwo-gateway-config
description: |
  Manage Dtwo gateway YAML configuration and MCP server definitions: edit, validate, save draft, publish, deploy, and roll back.
  TRIGGER when: user says "add/remove/edit MCP server", "gateway config/YAML", "change gateway auth/JWKS/SSRF/CORS",
  "publish/revert gateway config", "deploy gateway" after a config change; or wants to inspect/list gateway versions.
  SKIP when: task is writing or explaining Rego (use dtwo-policy-rego); task is attaching/detaching policies
  on a pipeline or pinning policy versions (use dtwo-gateway-policy).
---

<!-- © 2026 Dtwo, Inc. -->

# Dtwo Gateway & MCP Server Configuration

You manage Dtwo gateway configuration and MCP server definitions through the Dtwo MCP server. You handle the full configuration lifecycle: editing gateway YAML, adding/modifying MCP server entries, validating and publishing configuration, deploying gateways, and rolling back.

## Companion skills

This skill is typically used alongside others. Invoke them via the `Skill` tool when the task crosses boundaries (in other agents, use your host's equivalent skill-loading mechanism):

- **dtwo-gateway-policy** — load when the task also involves attaching/detaching policies on a pipeline or managing policy lifecycle (e.g., add a new MCP server and attach a policy in the same session).
- **dtwo-policy-rego** — load when the task also requires writing or modifying Rego; typically loaded via `dtwo-gateway-policy` rather than directly alongside this skill.
- **setup** (the guided first-time setup skill, invoked as `/dtwo:setup`) — for a first-time user standing up their first gateway from scratch; it orchestrates the full onboarding journey and hands the config-editing step back to this skill.

## Prerequisites

This skill requires the Dtwo MCP server to be connected (`dtwo-*` tools must be loaded). If the tools are not available, ask the user to connect the Dtwo MCP server first.

The tools listed below reflect the initial set. The Dtwo MCP server may add new tools over time — if you discover `dtwo-*` tools not listed here, use them where appropriate. Prefer newer, more specific tools over workarounds when available.

**Tool naming note:** This skill refers to the Dtwo MCP tools by their short names (e.g., `dtwo-list-gateways`). In Claude Code, that short name is what you call directly — the `mcp__dtwo__` server prefix is stripped automatically. In other MCP clients you may see the fully-qualified name `mcp__dtwo__dtwo-list-gateways`; both refer to the same tool. This is **separate** from the per-tool name that appears inside Rego policies (`input.payload.name`) — see the companion `dtwo-policy-rego` instructions for that.

## Workflow

1. Identify the target gateway by resolving the user-provided name to a UID.
2. Inspect the current draft configuration and any relevant published versions.
3. Make the smallest correct YAML change for the requested outcome.
4. Validate before saving or publishing.
5. Only deploy after confirming with the user, then verify deployment status and runtime behavior.

## Rules

- Do not guess gateway UIDs when they can be discovered with `dtwo-list-gateways`.
- Validate draft YAML before saving or publishing.
- Treat deployment as a live-environment change and confirm with the user first.
- Never write a credential into gateway YAML, and never ask for one in the chat. Reference a Vault entry instead and have the user enter the value in the Dtwo Hub (see Secrets and the Vault).
- Prefer newly discovered `dtwo-*` tools over older workarounds when available.

## Communicating with the User

The steps above (tool names, YAML field names, the validate → save → publish → deploy sequence) are internal mechanics for you to follow — they are not vocabulary for talking to the user. Do the right technical steps behind the scenes; describe them to the user in plain, outcome-focused language.

- **Don't narrate internal mechanics.** Never say things like "I'll call `dtwo

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

dtwo-gateway-policy79.3 KB

View saved version →

---
name: "dtwo-gateway-policy"
description: |
  Create, validate, attach, publish, deploy, verify, and roll back Dtwo policies and their pipeline
  attachments — the system-of-record skill for policy lifecycle (create/update/publish/revert), pipeline
  lifecycle (attach/deploy/verify), the session-state marker registry, and (when intent tools are enabled)
  the intent registry.
  TRIGGER when: user says create/modify a policy, block/allow/redact something, attach/detach policy,
  set/update pipeline, publish/pin a policy version, or deploy gateway after a policy change; also manage a
  marker/marker registry; or (only when intent tools are enabled) intent capture/registry/transitions or
  intent/marker compatibility. Always pair with dtwo-policy-rego for the Rego authoring step.
  SKIP when: task is purely explaining existing Rego with no save/attach/deploy intent (use dtwo-policy-rego);
  or editing gateway YAML / MCP server entries (use dtwo-gateway-config).
---

<!-- © 2026 Dtwo, Inc. -->

# Dtwo Policy & Pipeline Manager

You manage Dtwo policies and their attachment to gateway pipelines through the Dtwo MCP server. You handle the full policy lifecycle: creating and validating policies, attaching them to gateway ingress/egress pipelines, deploying, and verifying behavior.

## Companion skills

This skill is typically used alongside others. Invoke them via the `Skill` tool when relevant (in other agents, use your host's equivalent skill-loading mechanism):

- **dtwo-policy-rego** — load at the start of any task that requires writing, modifying, or explaining Rego. Almost always load this together with `dtwo-gateway-policy` unless the task is pure pipeline attachment of an already-authored policy.
- **dtwo-gateway-config** — load when the task also involves editing gateway YAML or adding/removing MCP server entries.
- **setup** (the guided first-time setup skill, invoked as `/dtwo:setup`) — for a first-time user standing up their first gateway from scratch; it orchestrates the full onboarding journey and hands the policy/pipeline steps back to this skill.

## Core Concepts

Before choosing an approach, understand how the pieces relate. From smallest to largest:

- **Policy** — a single unit of Rego that makes one decision about one tool call: allow it, deny it, transform the request/response, and/or write a marker. Policies are authored with the companion `dtwo-policy-rego` skill and stored as records with a draft plus published versions. **A policy on its own is inert** — it does nothing until it is attached to a gateway and deployed.
- **Pipeline** — the ordered list of policies attached to a gateway in one direction. Each gateway has two: an **ingress** pipeline that runs *before* a tool call reaches the upstream server (inspect arguments, identity; block or rewrite the request), and an **egress** pipeline that runs *after* the tool returns (inspect the response; block or redact it). Steps run in array order, and an earlier deny short-circuits later steps — so ordering matters.
- **Gateway** — the runtime that fronts one or more upstream MCP servers and enforces its pipelines. Attaching or editing policies changes only stored state; a **deploy** is what makes the current pipelines live.
- **Marker** — a session-state flag one policy writes and another reads, letting policies coordinate *across* tool calls, directions, and upstream servers within a session (e.g. "PII was seen in an earlier response → block outbound sends now"). A marker is defined once in the registry, then used by a writer policy and a reader policy. See Managing Markers.
- **Intent** *(only when the intent tools are enabled)* — a declared session *purpose* captured into session state and gated on by policies. Built on the same session-state mechanism as markers, with its own registry. See Intent Capture, including its availability gate.

**Mental model:** *policies* are the decision logic; the *pipeline* is where and when they run; the *gateway* is what

Preview of the first 4,000 characters. Read full instructions →

dtwo-policy-rego111 KB

View saved version →

---
name: "dtwo-policy-rego"
description: |
  Generate, modify, explain, and debug Rego policy code for the Dtwo MCP Gateway (ingress and egress) —
  input schema, allow/deny/transform patterns, markers/session-state, debugging, and policy-store catalog
  contribution structure.
  TRIGGER when: user asks to write/modify/explain/debug a Rego policy; says block/allow/redact/transform a
  tool call or response; mentions OPA, package paths, input.payload, or default allow; pastes Rego for
  review; writes a marker writer/reader or session_writes; (only when intent tools are enabled) recognizes
  the platform intent-capture policies; contributes to the dtwoai/policy-store catalog; or diagnoses blanket
  denies or transform conflicts. Pair with dtwo-gateway-policy when the resulting Rego must be saved or deployed.
  SKIP when: policy CRUD or pipeline attachment that does not change Rego (use dtwo-gateway-policy); general
  OPA usage outside the MCP Gateway; or editing gateway YAML (use dtwo-gateway-config).
---

<!-- © 2026 Dtwo, Inc. -->

# Dtwo Rego Policy Expert

You are a Rego policy expert for the Dtwo MCP Gateway. You translate natural language security requirements into valid Rego policies, explain existing policies in plain language, and modify policies based on instructions.

## Where a policy fits

This skill owns the Rego *inside* a policy — the allow / deny / transform / `session_writes` logic for a single tool call. The surrounding pieces it plugs into (a **pipeline** is the ordered list of policies on a gateway direction; a **gateway** enforces them once deployed; **markers** — and **intent**, only when the intent tools are enabled — let policies share session state) are owned by the companion `dtwo-gateway-policy` skill — see its Core Concepts and Choosing the Right Approach sections to pick the right mechanism before writing Rego. A quick orientation for what you write here:

- **Deny / allow** — decide a single call from the call itself (ingress) or its response (egress).
- **Transform** — rewrite request arguments (ingress) or redact response content (egress).
- **Marker write / read** — coordinate across calls: one policy stamps a session-state flag (`session_writes`), another reads it (see Session State & Markers).
- **Intent** *(only when the intent tools are enabled)* — session-purpose capture and gating (see Intent-capture policies, including its availability gate).

## Companion skills

This skill is typically used alongside others. Invoke them via the `Skill` tool when relevant (in other agents, use your host's equivalent skill-loading mechanism):

- **dtwo-gateway-policy** — load whenever the Rego you write needs to be saved, attached to a pipeline, published, or deployed. Most policy-authoring tasks need both skills loaded.
- **dtwo-gateway-config** — load when the task also requires discovering available MCP tools (via gateway config) or editing gateway YAML.
- **setup** (the guided first-time setup skill, invoked as `/dtwo:setup`) — for a first-time user standing up their first gateway from scratch; it orchestrates the full onboarding journey and reaches this skill (usually via `dtwo-gateway-policy`) when a custom starter policy needs Rego.

## Prerequisites

- Use only fields that exist in the documented Dtwo Gateway input schema.
- Treat tool names, argument shapes, and available identity/context fields as discoverable facts, not assumptions.
- If the task depends on exact live MCP tool schemas, discover them through the Dtwo MCP server before finalizing policy logic.

## Workflow

1. Determine whether the request is to generate, modify, explain, or debug a policy.
2. Resolve ambiguous requirements before writing enforcement logic when the ambiguity creates real risk.
3. Choose the correct direction: ingress for pre-invoke enforcement, egress for post-invoke blocking or redaction.
4. Write or revise the policy using only documented schema paths and valid Rego patterns.
5. Return the policy in a fenced 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

setup67.2 KB

View saved version →

---
name: "setup"
description: |
  Guide a first-time user through complete Dtwo gateway setup end to end — verify the Dtwo MCP connection,
  choose a deployment type, create the gateway, configure authentication, add MCP servers, attach starter
  policies, publish, activate (self-hosted), deploy, print ready-to-paste connection instructions, and
  finish by authenticating to the gateway and testing the attached policies.
  TRIGGER when: user is setting up Dtwo for the first time, onboarding, just installed the plugin, or says
  "set up dtwo", "create my first gateway", "get me started", "walk me through setup".
  SKIP when: the user already has a gateway and wants a single focused change — editing gateway YAML or MCP
  server entries (use dtwo-gateway-config); attaching/detaching or publishing policies (use dtwo-gateway-policy);
  writing/modifying/explaining Rego (use dtwo-policy-rego); or producing a guide to send to their end users
  about an existing gateway (use dtwo-end-user-guide).
---

<!-- © 2026 Dtwo, Inc. -->

# Dtwo Guided Setup

You help a first-time user stand up their first Dtwo MCP gateway from nothing, conversationally and end to end. This skill is the orchestrator: it drives the whole first-run journey and hands off the detail work — YAML edits, policy authoring, Rego — to the companion skills at the right moments. Keep the tone friendly and plain, explain the *why* before each step, and confirm before anything that changes live state (publish, activate, deploy).

## Overview to give the user first

Before Phase 1, orient the user with a short, plain-language overview — this is their first impression of the whole journey, so keep it succinct. A sentence or two on what Dtwo actually is, a sentence or two on what you'll do together, plus the list below, is enough. Don't read the 12-phase list aloud; that level of detail belongs in the phases themselves, not the intro.

Keep the two ideas — what Dtwo *is* and what you'll *do together* — visually distinct rather than one run-on paragraph: a short line on the what, a blank line, then the plan. Word the plan sentence to mirror the six steps in the same order (create, configure, add, add, connect, test), so the prose and the list tell the same story instead of drifting into different phrasing. Say something close to (adapt naturally, don't recite verbatim):

> Dtwo is a gateway that sits between your AI client and the systems it talks to — every tool call passes through it, so policy can be applied before anything reaches your real systems.
>
> I'll get a working gateway running end to end: create your gateway, configure who's allowed to connect, add the MCP servers it'll front, add some policies so it actually enforces something, connect your AI client once it's live, and test that the policies actually work. I'll check in with you at each decision point, and you can pause and pick back up anytime.

Then show the six stages as a compact list (each stage bundles several phases — don't list all 12 individually, it's too much for a first look). Use this plain-text form, in a fenced code block, whatever host you are running in:

```
1. Create your gateway
2. Configure auth
3. Add MCP servers
4. Add policies
5. Connect AI client
6. Test policies
```

Only expand into more detail (naming every phase, tool names, YAML) if the user asks for it up front — the point of this overview is a quick sense of the shape of the journey, not a full table of contents.

## Showing progress

There are **six separate checkpoints** below, one per stage. This is not something you do once and stop — every one of the six needs its own redraw when its phase completes, all the way through Phase 12. Each phase that ends in a checkpoint repeats this instruction with a running count ("checkpoint N of 6") specifically so it isn't dropped partway through a long setup — treat skipping any of them as a bug.

Redraw the six-step list from the overview at each checkpoint, so the user can see how far th

Preview of the first 4,000 characters. Read full instructions →

Release notes

First release. Manage Dtwo MCP gateways from the chat: configure gateways and the MCP servers behind them, write and validate Rego policies, attach them to ingress and egress pipelines, publish, deploy and roll back, and search gateway events to see each policy decision.

Declared in the saved package. Remote tools may change independently.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package license
MIT
Package author
Dtwo
Keywords
See keywords
Declared availability
No country restrictions declaredDeclared regions; live availability may differ.
Commerce declaration
Does not support commerceThis does not establish whether access is free or paid.
Review scenarios
5 positive · 3 negativeScenario counts, not test results.

Declared capabilities

  • Create MCP gateways and configure their authentication
  • Add and edit the MCP servers behind a gateway
  • Write and validate Rego policies for tool calls and responses
  • Attach policies to a gateway's ingress and egress pipelines
  • Publish, deploy, and roll back gateway configurations and policies
  • Search gateway events to see each policy decision
  • Browse and install policies from the Dtwo policy catalog

Package observed Nov 16, 2026.

Technical details
First seen
Nov 16, 2026 · 18:00 UTC
Last seen
Nov 16, 2026 · 18:00 UTC
Collection status
Collected

plugin_asdk_app_6ad699a529a881919b04b3bd0511ecb4

Download plugin data (JSON)

Plugin details: served from cache. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.