# AI Agent Guardrails Explained: What They Cover and What They Don't

> Guardrails are often treated as a universal safety layer for AI agents, but they're not. This piece explains what guardrails actually control, why they behave differently across coding agents, SaaS integrations, and custom-built systems, and how they differ from the runtime agentic remediations that sit alongside them.

- URL: https://www.geordie.ai/resources/guardrails-explained/
- Author: Hanah Darley
- Published: 2026-03-20
- Updated: 2026-03-23
- Type: Blog
- Topics: Discovery & Posture, Remediation

---

<div class="resource-standfirst">
  <p class="resource-standfirst__eyebrow">Agentic Security</p>
  <p class="resource-standfirst__deck">Understanding Guardrails in Agentic Systems</p>
  <p class="resource-standfirst__lede">Guardrails are one of the most discussed and most misunderstood concepts in enterprise AI. This explainer covers what they are, where they work, and - critically - what they don't cover on their own.</p>
</div>

## What is a guardrail?

A guardrail is a **design-time control** : something configured before an agent is deployed. It defines the boundaries within which an agent is permitted to operate: which tools it can call, what content it can produce, which actions are out of scope.

Think of guardrails as constraints written into the architecture itself. They shape what an agent can and cannot do before any action occurs. They are not passive observers, and they are not the same as responses to runtime behavior.

> _Guardrails set the rules of operation. They do not, on their own, monitor or respond to behavior once an agent is running across multiple systems._

## Where guardrails work well

In a contained system, where an agent operates within a single platform, calls a predefined set of tools, and never interacts with external services, centralized guardrails provide meaningful coverage. Because every action passes through a single control point, the guardrails can reliably inspect prompts, validate tool usage, enforce output constraints, and prevent prompt injection before anything happens.

A coding agent that only reads from a repository, runs predefined tests, and suggests changes, without touching anything outside that environment, fits this model well.

<style>
/* All rules scoped to .gd-wp — no global overrides */
.gd-wp {
  --peach:       #F2A374;
  --peach-light: #F7C4A2;
  --peach-pale:  #FDE8D4;
  --lav:         #C8B4DC;
  --lav-light:   #E2D7F0;
  --ink:         #1A1828;
  --ink-mid:     #3D3853;
  --ink-soft:    #7A7390;
  --safe:        #4CAF82;
  --safe-bg:     rgba(76,175,130,0.10);
  --safe-bd:     rgba(76,175,130,0.35);
  --warn:        #E8913A;
  --warn-bg:     rgba(232,145,58,0.10);
  --warn-bd:     rgba(232,145,58,0.35);
  --card:        #FFFFFF;
  --r:           12px;
  --ease:        cubic-bezier(0.4,0,0.2,1);
  font-family:   inherit;
  color:         var(--ink);
  line-height:   1.65;
}
.gd-wp *, .gd-wp *::before, .gd-wp *::after {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

/* Card */
.gd-wp__card {
  background: var(--card);
  border-radius: var(--r);
  border: 1px solid rgba(200,180,220,0.30);
  padding: 28px;
  box-shadow: 0 2px 16px rgba(26,24,40,0.07);
}

/* Scenario buttons */
.gd-wp__scenarios {
  display: flex;
  gap: 8px;
  flex-wrap: wrap;
  margin-bottom: 18px;
}
.gd-wp__scn {
  padding: 8px 16px;
  border-radius: 8px;
  border: 1.5px solid rgba(200,180,220,0.45);
  background: #F7F5FB;
  font-size: 0.87rem;
  font-weight: 500;
  color: var(--ink-mid);
  cursor: pointer;
  transition: all 0.2s var(--ease);
  font-family: inherit;
}
.gd-wp__scn:hover {
  background: #FFFFFF;
  border-color: var(--peach);
}
.gd-wp__scn--active {
  background: #fff;
  border-color: var(--peach);
  color: var(--ink);
  box-shadow: 0 2px 10px rgba(242,163,116,0.18);
}

/* Description */
.gd-wp__desc {
  font-size: 0.87rem;
  color: var(--ink-soft);
  font-style: italic;
  margin-bottom: 20px;
  min-height: 18px;
}

/* Controls */
.gd-wp__controls {
  display: flex;
  align-items: center;
  gap: 12px;
  margin-bottom: 8px;
}
.gd-wp__play {
  display: inline-flex;
  align-items: center;
  gap: 7px;
  padding: 10px 20px;
  border-radius: 9px;
  border: none;
  cursor: pointer;
  background: linear-gradient(135deg, var(--peach), #D97A50);
  color: #fff;
  font-size: 0.9rem;
  font-weight: 600;
  font-family: inherit;
  box-shadow: 0 3px 12px rgba(242,163,116,0.30);
  transition: all 0.2s var(--ease);
}
.gd-wp__play:hover:not(:disabled) {
  transform: translateY(-1px);
  box-shadow: 0 5px 16px rgba(242,163,116,0.40);
}
.gd-wp__play:disabled { opacity: 0.6; cursor: default; transform: none; }
.gd-wp__play svg { width: 13px; height: 13px; fill: #fff; }
.gd-wp__reset {
  padding: 9px 16px;
  border-radius: 9px;
  border: 1.5px solid rgba(200,180,220,0.5);
  background: #F7F5FB;
  font-size: 0.86rem;
  color: var(--ink-mid);
  cursor: pointer;
  font-family: inherit;
  transition: background 0.2s;
}
.gd-wp__reset:hover { background: #fff; }

/* Step list */
.gd-wp__steps { display: flex; flex-direction: column; }

/* Individual step */
.gd-wp__wrap {
  opacity: 0;
  transform: translateY(8px);
  transition: opacity 0.32s var(--ease), transform 0.32s var(--ease);
}
.gd-wp__wrap--show { opacity: 1; transform: translateY(0); }

.gd-wp__row {
  display: flex;
  align-items: center;
  gap: 12px;
  padding: 12px 16px;
  border-radius: 10px;
  border: 1.5px solid transparent;
  transition: all 0.25s var(--ease);
}
.gd-wp__row--inside  { background: #F7F5FB; border-color: rgba(200,180,220,0.40); }
.gd-wp__row--outside { background: #FEF4EC; border-color: rgba(232,145,58,0.30); }
.gd-wp__row--guard   { background: linear-gradient(135deg,#FEF0D0,#FDE8D4); border-color: rgba(242,163,116,0.50); }

.gd-wp__icon {
  width: 32px; height: 32px;
  border-radius: 50%;
  display: flex; align-items: center; justify-content: center;
  font-size: 0.95rem;
  background: #FFFFFF;
  border: 1.5px solid rgba(200,180,220,0.40);
  flex-shrink: 0;
}
.gd-wp__row--outside .gd-wp__icon { background: var(--warn-bg); border-color: var(--warn-bd); }
.gd-wp__row--guard   .gd-wp__icon { background: rgba(242,163,116,0.12); border-color: var(--peach); }

.gd-wp__text { flex: 1; }
.gd-wp__label { font-weight: 600; font-size: 0.92rem; color: var(--ink); }
.gd-wp__sub   { font-size: 0.78rem; color: var(--ink-soft); margin-top: 2px; }

.gd-wp__badge {
  flex-shrink: 0;
  font-size: 0.7rem;
  font-weight: 700;
  letter-spacing: 0.05em;
  padding: 3px 9px;
  border-radius: 20px;
  opacity: 0;
  transition: opacity 0.28s 0.12s;
  white-space: nowrap;
}
.gd-wp__badge--show  { opacity: 1; }
.gd-wp__badge--safe  { background: var(--safe-bg);            color: var(--safe); border: 1px solid var(--safe-bd); }
.gd-wp__badge--warn  { background: var(--warn-bg);            color: var(--warn); border: 1px solid var(--warn-bd); }
.gd-wp__badge--guard { background: rgba(242,163,116,0.14);    color: #B06030;     border: 1px solid rgba(242,163,116,0.38); }

/* Connector */
.gd-wp__conn { width: 2px; height: 22px; margin: 0 auto; overflow: hidden; }
.gd-wp__conn-fill {
  width: 100%; height: 0;
  background: linear-gradient(180deg, var(--peach-light), var(--lav));
  transition: height 0.38s var(--ease);
}
.gd-wp__conn-fill--on { height: 100%; }

/* Boundary marker */
.gd-wp__boundary {
  display: flex; align-items: center; gap: 10px;
  margin: 5px 0; opacity: 0; transition: opacity 0.35s;
}
.gd-wp__boundary--show { opacity: 1; }
.gd-wp__bline { flex: 1; border-top: 2px dashed rgba(232,145,58,0.38); }
.gd-wp__blabel {
  font-size: 0.7rem; font-weight: 700; letter-spacing: 0.1em;
  text-transform: uppercase; color: var(--warn); white-space: nowrap;
  padding: 3px 9px; border-radius: 20px;
  background: rgba(255,240,220,0.85);
  border: 1px solid rgba(232,145,58,0.28);
}

/* Coverage summary */
.gd-wp__summary {
  margin-top: 18px; padding: 16px 18px;
  border-radius: 10px;
  background: #F7F5FB;
  border: 1px solid rgba(200,180,220,0.35);
  opacity: 0; transform: translateY(6px);
  transition: opacity 0.38s, transform 0.38s;
}
.gd-wp__summary--show { opacity: 1; transform: translateY(0); }
.gd-wp__sum-row { display: flex; align-items: center; justify-content: space-between; margin-bottom: 8px; }
.gd-wp__sum-title { font-size: 0.76rem; font-weight: 700; letter-spacing: 0.08em; text-transform: uppercase; color: var(--ink-soft); }
.gd-wp__sum-pct   { font-size: 0.8rem; font-weight: 700; color: var(--safe); }
.gd-wp__bar  { height: 7px; border-radius: 4px; background: #E8E2F2; overflow: hidden; margin-bottom: 10px; }
.gd-wp__fill { height: 100%; border-radius: 4px; background: linear-gradient(90deg,var(--safe),#A8D8BE); width: 0; transition: width 0.75s var(--ease); }
.gd-wp__stats { display: flex; gap: 18px; }
.gd-wp__stat  { font-size: 0.8rem; color: var(--ink-soft); }
.gd-wp__stat span { font-weight: 700; }
.gd-wp__stat--safe span { color: var(--safe); }
.gd-wp__stat--warn span { color: var(--warn); }
.gd-wp__note { font-size: 0.8rem; color: var(--ink-soft); margin-top: 10px; line-height: 1.5; }
</style>

<div class="gd-wp">
  <div class="gd-wp__card">
    <!-- Scenario selector -->
    <div class="gd-wp__scenarios">
      <button class="gd-wp__scn gd-wp__scn--active" onclick="gdWP.selectScenario('coding',this)">Developer workflow</button>
      <button class="gd-wp__scn" onclick="gdWP.selectScenario('security',this)">Security operations</button>
      <button class="gd-wp__scn" onclick="gdWP.selectScenario('customer',this)">Customer automation</button>
    </div>
    <p class="gd-wp__desc" id="gdwp-desc">An agent reviews a pull request, checking code quality and security dependencies.</p>
    <div class="gd-wp__controls">
      <button class="gd-wp__play" id="gdwp-play" onclick="gdWP.play()">
        <svg viewBox="0 0 24 24"><path d="M8 5v14l11-7z"/></svg>
        Run workflow
      </button>
      <button class="gd-wp__reset" onclick="gdWP.reset()">↺ Reset</button>
    </div>
    <div class="gd-wp__steps" id="gdwp-steps"></div>
    <div class="gd-wp__summary" id="gdwp-summary">
      <div class="gd-wp__sum-row">
        <span class="gd-wp__sum-title">Guardrail coverage</span>
        <span class="gd-wp__sum-pct" id="gdwp-pct">0%</span>
      </div>
      <div class="gd-wp__bar"><div class="gd-wp__fill" id="gdwp-fill"></div></div>
      <div class="gd-wp__stats">
        <div class="gd-wp__stat gd-wp__stat--safe">Steps covered: <span id="gdwp-safe">0</span></div>
        <div class="gd-wp__stat gd-wp__stat--warn">Outside boundary: <span id="gdwp-warn">0</span></div>
      </div>
      <p class="gd-wp__note" id="gdwp-note"></p>
    </div>
  </div>
</div>

<script>
(function () {
  var SCENARIOS = {
    coding: {
      desc: 'An agent reviews a pull request, checking code quality and security dependencies.',
      note: 'The guardrails defined in the development environment stop at the repository boundary. Once the agent calls the CI/CD pipeline or external services, those interactions are outside the original orchestration layer.',
      steps: [
        { label: 'User request',              sub: 'Review PR #247 for security issues',              inside: true,  guard: false, icon: '💬' },
        { label: 'Agent reasoning',           sub: 'Plans: read diff, run tests, check deps',         inside: true,  guard: false, icon: '🧠' },
        { label: 'Orchestrator + guardrails', sub: 'Prompt validated — tools scoped to repository',   inside: true,  guard: true,  icon: '🛡' },
        { label: 'Repository API',            sub: 'Reads PR diff and commit history',                inside: true,  guard: false, icon: '📁' },
        { label: 'CI/CD pipeline',            sub: 'Triggers test suite — outside repo boundary',     inside: false, guard: false, icon: '⚙️' },
        { label: 'External security scanner', sub: 'Sends code context for vulnerability analysis',   inside: false, guard: false, icon: '🔍' },
        { label: 'Cloud deployment API',      sub: 'Checks deployment config — guardrails don\'t follow', inside: false, guard: false, icon: '☁️' }
      ]
    },
    security: {
      desc: 'A security copilot investigates a high-severity alert across the SOC stack.',
      note: 'The SIEM platform\'s guardrails apply within its own system. Once the copilot retrieves endpoint telemetry, calls threat intelligence feeds, or enriches context externally, each interaction operates under separate and often incompatible controls.',
      steps: [
        { label: 'Security alert',            sub: 'High severity: unusual authentication pattern',   inside: true,  guard: false, icon: '🚨' },
        { label: 'Agent + guardrails',        sub: 'Scope validated — limited to SOC tooling',        inside: true,  guard: true,  icon: '🛡' },
        { label: 'SIEM platform',             sub: 'Queries alert context and log history',           inside: true,  guard: false, icon: '📊' },
        { label: 'Endpoint telemetry',        sub: 'Retrieves host activity — separate system',       inside: false, guard: false, icon: '💻' },
        { label: 'Threat intelligence API',   sub: 'Checks IOC indicators externally',               inside: false, guard: false, icon: '🌐' },
        { label: 'Case management',           sub: 'Opens investigation ticket — combined context',   inside: false, guard: false, icon: '📋' },
        { label: 'External enrichment',       sub: 'Sends aggregated context for analysis',           inside: false, guard: false, icon: '📡' }
      ]
    },
    customer: {
      desc: 'A support agent processes an inbound customer request, retrieving account and billing context.',
      note: 'Internal data retrieved from the CRM and billing systems may travel in subsequent calls to external services. The workflow completes successfully — but context has moved beyond the original governance boundary.',
      steps: [
        { label: 'Customer request',          sub: 'Inbound: billing dispute, account #8821',         inside: true,  guard: false, icon: '📨' },
        { label: 'Agent + guardrails',        sub: 'Request validated — scoped to support tools',     inside: true,  guard: true,  icon: '🛡' },
        { label: 'CRM lookup',                sub: 'Retrieves account history and preferences',        inside: true,  guard: false, icon: '👤' },
        { label: 'Billing system',            sub: 'Pulls invoice records and payment history',        inside: true,  guard: false, icon: '💳' },
        { label: 'Knowledge base',            sub: 'Fetches relevant policy — partial scope',          inside: false, guard: false, icon: '📚' },
        { label: 'Translation API',           sub: 'Sends combined customer context externally',       inside: false, guard: false, icon: '🌍' },
        { label: 'Automated response',        sub: 'Action taken outside original guardrail scope',    inside: false, guard: false, icon: '📤' }
      ]
    }
  };

  var current = 'coding';
  var playing = false;
  var timers  = [];

  window.gdWP = {
    selectScenario: function (name, btn) {
      if (playing) return;
      current = name;
      document.querySelectorAll('.gd-wp__scn').forEach(function (b) { b.classList.remove('gd-wp__scn--active'); });
      btn.classList.add('gd-wp__scn--active');
      document.getElementById('gdwp-desc').textContent = SCENARIOS[name].desc;
      this.reset();
    },
    play: function () {
      if (playing) return;
      playing = true;
      document.getElementById('gdwp-play').disabled = true;

      var scn  = SCENARIOS[current];
      var list = document.getElementById('gdwp-steps');
      list.innerHTML = '';

      scn.steps.forEach(function (step, i) {
        if (i > 0) {
          var conn = document.createElement('div');
          conn.className = 'gd-wp__conn';
          conn.innerHTML = '<div class="gd-wp__conn-fill" id="gdwp-conn-' + i + '"></div>';
          list.appendChild(conn);
        }
        if (i > 0 && !step.inside && scn.steps[i - 1].inside) {
          var bm = document.createElement('div');
          bm.className = 'gd-wp__boundary';
          bm.id = 'gdwp-bm-' + i;
          bm.innerHTML = '<div class="gd-wp__bline"></div><div class="gd-wp__blabel">Guardrail boundary</div><div class="gd-wp__bline"></div>';
          list.appendChild(bm);
        }
        var wrap = document.createElement('div');
        wrap.className = 'gd-wp__wrap';
        wrap.id = 'gdwp-step-' + i;
        var rowCls   = step.guard ? 'gd-wp__row--guard' : (step.inside ? 'gd-wp__row--inside' : 'gd-wp__row--outside');
        var badgeCls = step.guard ? 'gd-wp__badge--guard' : (step.inside ? 'gd-wp__badge--safe' : 'gd-wp__badge--warn');
        var badgeTxt = step.guard ? 'Guardrail check' : (step.inside ? 'Covered' : 'Outside boundary');
        wrap.innerHTML =
          '<div class="gd-wp__row ' + rowCls + '">' +
            '<div class="gd-wp__icon">' + step.icon + '</div>' +
            '<div class="gd-wp__text">' +
              '<div class="gd-wp__label">' + step.label + '</div>' +
              '<div class="gd-wp__sub">'   + step.sub   + '</div>' +
            '</div>' +
            '<div class="gd-wp__badge ' + badgeCls + '" id="gdwp-badge-' + i + '">' + badgeTxt + '</div>' +
          '</div>';
        list.appendChild(wrap);
      });

      var safeCount = 0, warnCount = 0;
      scn.steps.forEach(function (step, i) {
        var delay = i * 680;
        if (i > 0) {
          timers.push(setTimeout(function () {
            var c = document.getElementById('gdwp-conn-' + i);
            if (c) c.classList.add('gd-wp__conn-fill--on');
          }, delay - 180));
        }
        if (i > 0 && !step.inside && scn.steps[i - 1].inside) {
          timers.push(setTimeout(function () {
            var b = document.getElementById('gdwp-bm-' + i);
            if (b) b.classList.add('gd-wp__boundary--show');
          }, delay - 80));
        }
        timers.push(setTimeout(function () {
          var w = document.getElementById('gdwp-step-' + i);
          if (w) w.classList.add('gd-wp__wrap--show');
        }, delay));
        timers.push(setTimeout(function () {
          var badge = document.getElementById('gdwp-badge-' + i);
          if (badge) badge.classList.add('gd-wp__badge--show');
          if (step.inside || step.guard) safeCount++;
          else warnCount++;
        }, delay + 340));
      });

      var endDelay = scn.steps.length * 680 + 400;
      timers.push(setTimeout(function () {
        var total = scn.steps.length;
        var pct   = Math.round((safeCount / total) * 100);
        document.getElementById('gdwp-safe').textContent = safeCount;
        document.getElementById('gdwp-warn').textContent = warnCount;
        document.getElementById('gdwp-pct').textContent  = pct + '%';
        document.getElementById('gdwp-note').textContent = scn.note;
        var sum = document.getElementById('gdwp-summary');
        sum.classList.add('gd-wp__summary--show');
        setTimeout(function () { document.getElementById('gdwp-fill').style.width = pct + '%'; }, 80);
        playing = false;
        var btn = document.getElementById('gdwp-play');
        btn.disabled = false;
        btn.innerHTML = '<svg viewBox="0 0 24 24"><path d="M8 5v14l11-7z"/></svg> Run again';
      }, endDelay));
    },
    reset: function () {
      timers.forEach(clearTimeout);
      timers = [];
      playing = false;
      document.getElementById('gdwp-steps').innerHTML = '';
      var sum = document.getElementById('gdwp-summary');
      sum.classList.remove('gd-wp__summary--show');
      document.getElementById('gdwp-fill').style.width = '0';
      var btn = document.getElementById('gdwp-play');
      btn.disabled = false;
      btn.innerHTML = '<svg viewBox="0 0 24 24"><path d="M8 5v14l11-7z"/></svg> Run workflow';
    }
  };
}());
</script>

## Why guardrails don't apply universally

Enterprise agents rarely stay inside a single platform. A workflow that begins in one environment will often retrieve context from another, trigger actions in a third, and call external services along the way. This is by design. It is what makes agents useful.

But once an agent begins operating across systems, the guardrails defined in the original orchestration layer no longer govern the full decision chain. Each external system may enforce its own controls — but those controls don't communicate with each other, and none of them govern the full sequence of agent actions.

This transition from contained to distributed often happens gradually. A tool is added to improve accuracy. An API is introduced to enrich context. An integration allows action in another system. Each step is reasonable. The cumulative effect is an agent that operates across several environments — none of which share a unified governance model.

<style>
/* All rules scoped to .gd-ab — no global overrides */
.gd-ab {
  --peach:      #F2A374;
  --peach-pale: #FDE8D4;
  --lav:        #C8B4DC;
  --lav-light:  #E2D7F0;
  --ink:        #1A1828;
  --ink-mid:    #3D3853;
  --ink-soft:   #7A7390;
  --safe:       #4CAF82;
  --safe-bg:    rgba(76,175,130,0.09);
  --safe-bd:    rgba(76,175,130,0.28);
  --warn:       #E8913A;
  --warn-bg:    rgba(232,145,58,0.09);
  --warn-bd:    rgba(232,145,58,0.28);
  --card:       #FFFFFF;
  --r:          12px;
  --ease:       cubic-bezier(0.4,0,0.2,1);
  font-family:  inherit;
  color:        var(--ink);
  line-height:  1.65;
}
.gd-ab *, .gd-ab *::before, .gd-ab *::after {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

/* Card */
.gd-ab__card {
  background: var(--card);
  border-radius: var(--r);
  border: 1px solid rgba(200,180,220,0.30);
  padding: 28px;
  box-shadow: 0 2px 16px rgba(26,24,40,0.07);
}

/* Agent type selectors */
.gd-ab__selectors {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 10px;
  margin-bottom: 24px;
}
@media (max-width: 580px) {
  .gd-ab__selectors { grid-template-columns: 1fr; }
}
.gd-ab__sel {
  position: relative;
  padding: 18px 16px;
  border-radius: 11px;
  cursor: pointer;
  border: 2px solid rgba(200,180,220,0.35);
  background: #F7F5FB;
  transition: all 0.22s var(--ease);
  text-align: left;
  font-family: inherit;
  width: 100%;
}
.gd-ab__sel:hover { background: #FFFFFF; border-color: rgba(242,163,116,0.55); }
.gd-ab__sel--active { background: #fff; border-color: var(--peach); box-shadow: 0 3px 14px rgba(242,163,116,0.16); }
.gd-ab__sel-pip {
  position: absolute; top: 9px; right: 11px;
  font-size: 0.62rem; font-weight: 700; letter-spacing: 0.07em; text-transform: uppercase;
  background: var(--peach); color: #fff; padding: 2px 7px; border-radius: 8px;
  opacity: 0; transition: opacity 0.18s;
}
.gd-ab__sel--active .gd-ab__sel-pip { opacity: 1; }
.gd-ab__sel-icon { font-size: 1.5rem; margin-bottom: 7px; display: block; }
.gd-ab__sel-name { font-weight: 700; font-size: 0.92rem; color: var(--ink); display: block; margin-bottom: 3px; }
.gd-ab__sel-desc { font-size: 0.77rem; color: var(--ink-soft); line-height: 1.4; display: block; }

/* Diagram layout */
.gd-ab__diagram { display: flex; gap: 14px; }
.gd-ab__layers  { flex: 1; display: flex; flex-direction: column; gap: 5px; }

/* Individual layer */
.gd-ab__layer {
  display: flex; align-items: center; gap: 12px;
  padding: 14px 16px;
  border-radius: 10px;
  cursor: pointer;
  border: 1.5px solid transparent;
  position: relative;
  overflow: hidden;
  transition: all 0.28s var(--ease);
}
.gd-ab__layer::before {
  content: '';
  position: absolute; left: 0; top: 0; bottom: 0; width: 4px;
  border-radius: 10px 0 0 10px;
  transition: background 0.28s;
}
.gd-ab__layer--full { background: #EEF8F3; border-color: rgba(76,175,130,0.30); }
.gd-ab__layer--full::before { background: var(--safe); }
.gd-ab__layer--part { background: #FEF4EC; border-color: rgba(232,145,58,0.30); }
.gd-ab__layer--part::before { background: var(--peach); }
.gd-ab__layer--none { background: #F2F1F5; border-color: rgba(122,115,144,0.20); opacity: 0.75; }
.gd-ab__layer--none::before { background: var(--ink-soft); }
.gd-ab__layer:hover  { transform: translateX(4px); filter: brightness(1.04); }
.gd-ab__layer--open  { border-color: rgba(200,180,220,0.5) !important; }

.gd-ab__l-icon  { font-size: 1.05rem; flex-shrink: 0; width: 26px; text-align: center; }
.gd-ab__l-body  { flex: 1; }
.gd-ab__l-name  { font-weight: 600; font-size: 0.88rem; color: var(--ink); }
.gd-ab__l-hint  { font-size: 0.74rem; color: var(--ink-soft); margin-top: 2px; }
.gd-ab__l-badge {
  flex-shrink: 0; font-size: 0.66rem; font-weight: 700;
  letter-spacing: 0.06em; text-transform: uppercase;
  padding: 3px 8px; border-radius: 10px; white-space: nowrap;
}
.gd-ab__layer--full .gd-ab__l-badge { background: #D6F0E4; color: #2E7D55; border: 1px solid rgba(76,175,130,0.35); }
.gd-ab__layer--part .gd-ab__l-badge { background: #FDEBD8; color: #B06030; border: 1px solid rgba(232,145,58,0.35); }
.gd-ab__layer--none .gd-ab__l-badge { background: #E8E6EE; color: var(--ink-soft); border: 1px solid rgba(122,115,144,0.25); }
.gd-ab__l-chev { font-size: 0.65rem; color: var(--ink-soft); transition: transform 0.22s; flex-shrink: 0; }
.gd-ab__layer--open .gd-ab__l-chev { transform: rotate(180deg); }

/* Detail panel */
.gd-ab__detail {
  max-height: 0; overflow: hidden;
  transition: max-height 0.38s var(--ease), opacity 0.28s;
  opacity: 0;
}
.gd-ab__detail--open { max-height: 320px; opacity: 1; }
.gd-ab__detail-inner {
  margin: 0 0 5px;
  padding: 14px 16px;
  background: #FAFAFA;
  border-radius: 0 0 10px 10px;
  border: 1.5px solid rgba(200,180,220,0.30);
  border-top: none;
  font-size: 0.86rem;
  color: var(--ink-mid);
  line-height: 1.6;
}
.gd-ab__detail-inner p { margin-bottom: 10px; color: var(--ink-mid); font-size: 0.86rem; }
.gd-ab__detail-inner p:last-child { margin-bottom: 0; }
.gd-ab__covers { margin-top: 10px; }
.gd-ab__covers strong {
  display: block; margin-bottom: 4px;
  font-size: 0.68rem; font-weight: 700;
  letter-spacing: 0.09em; text-transform: uppercase;
}
.gd-ab__covers--good strong { color: var(--safe); }
.gd-ab__covers--miss strong { color: var(--warn); }
.gd-ab__covers--miss { margin-top: 8px; }

/* Legend + coverage bar */
.gd-ab__aside {
  display: flex; flex-direction: column; gap: 0;
  width: 118px; padding: 14px 0;
  flex-shrink: 0;
}
@media (max-width: 600px) { .gd-ab__aside { display: none; } }
.gd-ab__legend-title {
  font-size: 0.68rem; font-weight: 700; letter-spacing: 0.09em;
  text-transform: uppercase; color: var(--ink-soft); margin-bottom: 8px;
}
.gd-ab__leg { display: flex; align-items: center; gap: 7px; font-size: 0.74rem; color: var(--ink-soft); margin-bottom: 6px; }
.gd-ab__dot { width: 9px; height: 9px; border-radius: 50%; flex-shrink: 0; }
.gd-ab__dot--full { background: var(--safe); }
.gd-ab__dot--part { background: var(--peach); }
.gd-ab__dot--none { background: var(--ink-soft); opacity: 0.45; }

.gd-ab__reach {
  margin-top: 16px; padding: 12px;
  border-radius: 8px; background: #F7F5FB;
  border: 1px solid rgba(200,180,220,0.30);
}
.gd-ab__reach-lbl { font-size: 0.74rem; font-weight: 600; color: var(--ink-mid); margin-bottom: 6px; }
.gd-ab__reach-track { height: 6px; border-radius: 3px; background: #E8E2F2; overflow: hidden; }
.gd-ab__reach-fill  { height: 100%; border-radius: 3px; background: linear-gradient(90deg,var(--safe),var(--peach)); transition: width 0.45s var(--ease); }
.gd-ab__reach-sub   { font-size: 0.7rem; color: var(--ink-soft); margin-top: 5px; }
</style>

<div class="gd-ab">
  <div class="gd-ab__card">
    <!-- Agent type selectors -->
    <div class="gd-ab__selectors">
      <button class="gd-ab__sel gd-ab__sel--active" onclick="gdAB.select('coding',this)">
        <span class="gd-ab__sel-pip">Selected</span>
        <span class="gd-ab__sel-icon">🖥</span>
        <span class="gd-ab__sel-name">Coding agent</span>
        <span class="gd-ab__sel-desc">Terminal or IDE-based, developer-configured</span>
      </button>
      <button class="gd-ab__sel" onclick="gdAB.select('saas',this)">
        <span class="gd-ab__sel-pip">Selected</span>
        <span class="gd-ab__sel-icon">☁️</span>
        <span class="gd-ab__sel-name">SaaS agent</span>
        <span class="gd-ab__sel-desc">Platform-managed, vendor-enforced controls</span>
      </button>
      <button class="gd-ab__sel" onclick="gdAB.select('custom',this)">
        <span class="gd-ab__sel-pip">Selected</span>
        <span class="gd-ab__sel-icon">⚙️</span>
        <span class="gd-ab__sel-name">Custom-built agent</span>
        <span class="gd-ab__sel-desc">Framework or code-based, developer-defined</span>
      </button>
    </div>
    <!-- Architecture diagram -->
    <div class="gd-ab__diagram">
      <div class="gd-ab__layers" id="gdab-layers"></div>
      <div class="gd-ab__aside">
        <div class="gd-ab__legend-title">Coverage</div>
        <div class="gd-ab__leg"><div class="gd-ab__dot gd-ab__dot--full"></div>Governed</div>
        <div class="gd-ab__leg"><div class="gd-ab__dot gd-ab__dot--part"></div>Partial</div>
        <div class="gd-ab__leg"><div class="gd-ab__dot gd-ab__dot--none"></div>Ungoverned</div>
        <div class="gd-ab__reach">
          <div class="gd-ab__reach-lbl">Guardrail reach</div>
          <div class="gd-ab__reach-track"><div class="gd-ab__reach-fill" id="gdab-fill" style="width:40%"></div></div>
          <div class="gd-ab__reach-sub" id="gdab-sub">2 of 5 layers</div>
        </div>
      </div>
    </div>
  </div>
</div>

<script>
(function () {
  var DATA = {
    coding: {
      pct: '40%', sub: '2 of 5 layers',
      layers: [
        {
          id: 'input', icon: '💬', name: 'User input', hint: 'CLI or IDE interface', cov: 'full', badge: 'Governed',
          detail: 'Instructions arrive via terminal or IDE. The agent interprets the prompt and plans its task within the development environment.',
          covers: 'Prompt scope, task framing, initial instruction validation',
          misses: 'No restriction on how the agent interprets ambiguous instructions; no cross-session context tracking'
        },
        {
          id: 'reasoning', icon: '🧠', name: 'LLM reasoning', hint: 'Model plans tool usage', cov: 'full', badge: 'Governed',
          detail: 'The model reasons about the task, planning which tools to call and in what order. The system prompt shapes its behaviour at this stage.',
          covers: 'Task decomposition, tool selection intent, output framing',
          misses: 'Guardrails cannot inspect the model\'s internal chain-of-thought — only its outputs and tool calls'
        },
        {
          id: 'enforcement', icon: '🛡', name: 'System prompt + local config', hint: 'Lightweight, developer-defined', cov: 'part', badge: 'Partial',
          detail: 'Guardrails are defined through system prompts and local configuration. Enforcement depends on how the model interprets these instructions — there is no hard platform stop.',
          covers: 'Tool scoping, file access restrictions, branch protection rules',
          misses: 'No hard enforcement — constraints can be reasoned around. No visibility into what happens outside the local context'
        },
        {
          id: 'tools', icon: '🔧', name: 'Repository + file system', hint: 'Within developer-defined scope', cov: 'part', badge: 'Partial',
          detail: 'Tools within the repository scope can be constrained. Guardrails can restrict file access and prevent modification of protected branches.',
          covers: 'Repository reads, predefined test execution, local file inspection',
          misses: 'Guardrails must be explicitly maintained as tool configurations expand'
        },
        {
          id: 'external', icon: '☁️', name: 'CI/CD, cloud APIs, external services', hint: 'Outside guardrail scope', cov: 'none', badge: 'Ungoverned',
          detail: 'Once the agent calls CI/CD pipelines, cloud infrastructure, or external analysis tools, the local guardrails no longer apply.',
          covers: 'Nothing — each external system is independently governed, if at all',
          misses: 'Context from the repository may travel in calls to external services; no unified governance across the chain'
        }
      ]
    },
    saas: {
      pct: '55%', sub: '~3 of 5 layers',
      layers: [
        {
          id: 'input', icon: '💬', name: 'User query / platform trigger', hint: 'Chat interface or automation', cov: 'full', badge: 'Governed',
          detail: 'Instructions arrive through the platform — a chat interface, form submission, or automated trigger. The vendor controls how input is received and validated.',
          covers: 'Input validation, session authentication, role-based access to the platform',
          misses: 'The platform cannot validate the intent behind a request, only its structural form'
        },
        {
          id: 'reasoning', icon: '🧠', name: 'LLM reasoning', hint: 'Constrained by platform capabilities', cov: 'full', badge: 'Governed',
          detail: 'The model reasons within the capability set the platform exposes. Vendors control which capabilities are available, limiting the agent\'s effective reasoning surface.',
          covers: 'Task framing within the platform\'s defined scope, tool selection from permitted connectors',
          misses: 'Platform reasoning constraints may be too broad or narrow for specific enterprise use cases'
        },
        {
          id: 'enforcement', icon: '🛡', name: 'Platform identity + connector policies', hint: 'Vendor-enforced, ecosystem-level', cov: 'full', badge: 'Governed',
          detail: 'Guardrails are enforced at the platform level — identity verification, connector permissions, and action scopes are controlled by the vendor. More robust than prompt-level enforcement, but scoped to the ecosystem.',
          covers: 'Identity verification, connector-level permissions, action scopes tied to Microsoft Graph, ServiceNow, and similar',
          misses: 'Platform controls stop at the ecosystem boundary — external services are out of scope'
        },
        {
          id: 'tools', icon: '🔧', name: 'Platform-native tools', hint: 'Strong within ecosystem, limited beyond', cov: 'part', badge: 'Partial',
          detail: 'The platform controls which tools are available within its ecosystem. Permissions are well-defined for native connectors. Cross-platform tool calls introduce governance gaps.',
          covers: 'Native connector actions, platform-managed API calls, ecosystem-scoped data access',
          misses: 'Any tool or API outside the vendor\'s ecosystem operates outside platform governance'
        },
        {
          id: 'external', icon: '☁️', name: 'External APIs + other platforms', hint: 'Outside platform scope', cov: 'none', badge: 'Ungoverned',
          detail: 'When the agent calls services outside the platform ecosystem, the vendor\'s guardrails stop applying. Output passed downstream is governed by whatever controls that system enforces.',
          covers: 'Nothing — each external system is independently governed',
          misses: 'Incompatibility between platform policies and external controls; no shared context or enforcement model'
        }
      ]
    },
    custom: {
      pct: '45%', sub: '2 of 5 layers',
      layers: [
        {
          id: 'input', icon: '💬', name: 'User input / API trigger', hint: 'Developer-controlled intake', cov: 'full', badge: 'Governed',
          detail: 'Input arrives through a custom-built interface or API. The developer controls how input is validated and passed to the agent.',
          covers: 'Input schema validation, API authentication, request sanitisation',
          misses: 'Quality depends entirely on developer investment — poorly validated inputs may pass through'
        },
        {
          id: 'reasoning', icon: '🧠', name: 'LLM reasoning', hint: 'Shaped by developer-defined context', cov: 'full', badge: 'Governed',
          detail: 'The model reasons within parameters the developer has established — custom system prompts, tool definitions, and any fine-tuning. More configurable, but proportionally more maintenance-intensive.',
          covers: 'Custom task framing, tool selection from the configured set, output constraints',
          misses: 'No hard stops — enforcement depends on how well the developer has specified constraints'
        },
        {
          id: 'enforcement', icon: '🛡', name: 'Framework middleware + validators', hint: 'Developer-defined, maintenance-intensive', cov: 'part', badge: 'Partial',
          detail: 'Guardrails are implemented directly in code — as pre/post-call hooks, validation layers, or middleware. Coverage is strong where explicitly implemented; each new tool requires its own enforcement logic.',
          covers: 'Output validation, tool call filtering, custom policy enforcement where explicitly coded',
          misses: 'Governance scales with developer effort — gaps appear where enforcement logic hasn\'t been written or updated'
        },
        {
          id: 'tools', icon: '🔧', name: 'Configured APIs + databases', hint: 'Scope grows with tool count', cov: 'part', badge: 'Partial',
          detail: 'The developer explicitly configures which tools are available and applies guardrails to each. As the tool count grows, so does the configuration surface.',
          covers: 'Explicitly configured tool calls, developer-defined access controls per integration',
          misses: 'Guardrails must be updated each time a tool is added or changed; no automatic enforcement inheritance'
        },
        {
          id: 'external', icon: '☁️', name: 'Other agents + third-party workflows', hint: 'Outside framework scope', cov: 'none', badge: 'Ungoverned',
          detail: 'When this agent interacts with external systems — including other agents — its internal guardrails don\'t extend. Multi-agent workflows mean no single framework governs the full decision chain.',
          covers: 'Nothing — external systems and other agents operate under separate governance models',
          misses: 'Multi-agent orchestration creates governance chains where each link enforces only its own rules'
        }
      ]
    }
  };

  var currentType  = 'coding';
  var openLayerId  = null;

  function render(type) {
    var d = DATA[type];
    var container = document.getElementById('gdab-layers');
    container.innerHTML = '';
    openLayerId = null;

    d.layers.forEach(function (layer) {
      var layerEl = document.createElement('div');
      layerEl.className = 'gd-ab__layer gd-ab__layer--' + layer.cov;
      layerEl.id = 'gdab-layer-' + layer.id;
      layerEl.setAttribute('onclick', 'gdAB.toggleLayer("' + layer.id + '")');
      layerEl.innerHTML =
        '<div class="gd-ab__l-icon">' + layer.icon + '</div>' +
        '<div class="gd-ab__l-body">' +
          '<div class="gd-ab__l-name">' + layer.name + '</div>' +
          '<div class="gd-ab__l-hint">' + layer.hint + '</div>' +
        '</div>' +
        '<div class="gd-ab__l-badge">' + layer.badge + '</div>' +
        '<div class="gd-ab__l-chev">▼</div>';
      container.appendChild(layerEl);

      var detail = document.createElement('div');
      detail.className = 'gd-ab__detail';
      detail.id = 'gdab-detail-' + layer.id;
      detail.innerHTML =
        '<div class="gd-ab__detail-inner">' +
          '<p>' + layer.detail + '</p>' +
          '<div class="gd-ab__covers gd-ab__covers--good"><strong>What it covers</strong>' + layer.covers + '</div>' +
          '<div class="gd-ab__covers gd-ab__covers--miss"><strong>Where it ends</strong>' + layer.misses + '</div>' +
        '</div>';
      container.appendChild(detail);
    });

    document.getElementById('gdab-fill').style.width = d.pct;
    document.getElementById('gdab-sub').textContent  = d.sub;
  }

  window.gdAB = {
    select: function (type, btn) {
      currentType = type;
      document.querySelectorAll('.gd-ab__sel').forEach(function (b) { b.classList.remove('gd-ab__sel--active'); });
      btn.classList.add('gd-ab__sel--active');
      render(type);
    },
    toggleLayer: function (id) {
      if (openLayerId && openLayerId !== id) {
        var prevLayer  = document.getElementById('gdab-layer-'  + openLayerId);
        var prevDetail = document.getElementById('gdab-detail-' + openLayerId);
        if (prevLayer)  prevLayer.classList.remove('gd-ab__layer--open');
        if (prevDetail) prevDetail.classList.remove('gd-ab__detail--open');
      }
      var layerEl  = document.getElementById('gdab-layer-'  + id);
      var detailEl = document.getElementById('gdab-detail-' + id);
      if (openLayerId === id) {
        layerEl.classList.remove('gd-ab__layer--open');
        detailEl.classList.remove('gd-ab__detail--open');
        openLayerId = null;
      } else {
        layerEl.classList.add('gd-ab__layer--open');
        detailEl.classList.add('gd-ab__detail--open');
        openLayerId = id;
      }
    }
  };

  render('coding');
}());
</script>

### The portability problem

A guardrail defined in a coding agent does not transfer to a SaaS platform. A policy enforced inside a vendor ecosystem does not apply when output is passed to a downstream agent. The enforcement mechanisms are incompatible, and none share a unified view of the workflow as it spans systems.

Different frameworks implement guardrails in different ways. Some rely on prompt constraints. Others inspect tool calls. Some operate as middleware, and some exist only during development.

In a coding environment, an agent running through tools like Claude Code typically relies on prompt-level constraints, repository scoping, and local configuration. Enforcement depends heavily on how the agent interprets instructions in that context.

In a cloud or SaaS environment, such as a copilot built in Microsoft Copilot Studio, guardrails are enforced through identity, connectors, and predefined action scopes tied to services like Microsoft Graph or internal APIs. Control is strongest within that ecosystem.

Both approaches are effective within their respective boundaries. The challenge appears when workflows span across them. An agent may generate output in a development environment that is passed into a SaaS copilot. A cloud-based agent may call external APIs or trigger developer workflows. Each system enforces its own controls, but those controls do not extend across the full sequence of actions.

Even when guardrails are correctly implemented in each system, they remain blind to how decisions connect across them. The result is fragmented governance: what is constrained in one environment may be unconstrained in the next, even though the workflow is continuous.

### Where this appears in practice

The gap becomes clearer when looking at how agents operate in real environments.

In development workflows, a coding agent may retrieve code from a repository, run validation checks, trigger a build pipeline, and call an external debugging service. Each action is authorized, yet the workflow extends beyond the environment where guardrails were originally defined. Context from the repository may appear in a debugging request sent to an external service. The request is legitimate. The data flow is not always intended.

In business workflows, an agent handling a customer request may retrieve account data, reference internal documentation, and call an external service to summarize or transform the response. Each step is permitted. If internal context is carried into that external call, sensitive information may leave the organization without any single control being violated.

These outcomes do not come from a single incorrect action. They emerge from how agents combine context, tools, and decisions across systems. Seeing them requires knowing how decisions unfold step by step, which tools are invoked, and how context moves between systems. Without that, organizations are governing architecture diagrams rather than operational behavior.

<p class="resource-section-eyebrow">Design vs Response</p>

### Guardrails and remediations are not the same thing

They operate at different phases of an agent's lifecycle, address different problems, and require different capabilities to implement. Understanding the distinction matters: conflating the two leads to governance models that appear complete but leave significant gaps at runtime.

<style>
/* All rules scoped to .gd-vs — no global overrides */
.gd-vs {
  --peach:     #F2A374;
  --peach-pale:#FDE8D4;
  --lav:       #C8B4DC;
  --lav-pale:  #EAE0F5;
  --ink:       #1A1828;
  --ink-mid:   #3D3853;
  --ink-soft:  #7A7390;
  --warn:      #E8913A;
  --r:         12px;
  --ease:      cubic-bezier(0.4,0,0.2,1);
  font-family: inherit;
  color:       var(--ink);
  line-height: 1.65;
}
.gd-vs *, .gd-vs *::before, .gd-vs *::after {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

/* ── Lifecycle bar ── */
.gd-vs__lifecycle {
  display: flex;
  border-radius: var(--r);
  overflow: hidden;
  border: 1px solid rgba(200,180,220,0.25);
  margin-bottom: 20px;
  box-shadow: 0 2px 16px rgba(26,24,40,0.06);
}
@media (max-width: 500px) {
  .gd-vs__lifecycle { flex-direction: column; }
}
.gd-vs__phase {
  flex: 1;
  padding: 18px 16px;
  text-align: center;
  font-size: 0.88rem;
  color: var(--ink-mid);
  font-family: inherit;
  position: relative;
}
.gd-vs__phase::before {
  content: '';
  position: absolute;
  top: 0; left: 0; right: 0;
  height: 4px;
}
.gd-vs__phase-lbl {
  display: block;
  font-size: 0.68rem;
  font-weight: 700;
  letter-spacing: 0.1em;
  text-transform: uppercase;
  margin-bottom: 5px;
  color: var(--ink-soft);
}
.gd-vs__phase-note {
  display: block;
  font-size: 0.72rem;
  font-style: italic;
  margin-top: 5px;
  color: var(--ink-soft);
}
.gd-vs__phase--a { background: linear-gradient(160deg, #FEF3D0, #FDE8D4); }
.gd-vs__phase--a::before { background: var(--peach); }
.gd-vs__phase--b { background: linear-gradient(160deg, #FDE8D4, #F5D0E8); }
.gd-vs__phase--b::before { background: #E08AB0; }
.gd-vs__phase--c { background: linear-gradient(160deg, #EFE0F5, #E2D7F0); }
.gd-vs__phase--c::before { background: var(--lav); }

/* ── VS card ── */
.gd-vs__card {
  background: #FFFFFF;
  border-radius: var(--r);
  border: 1px solid rgba(200,180,220,0.30);
  overflow: hidden;
  box-shadow: 0 2px 16px rgba(26,24,40,0.07);
}

/* Header row */
.gd-vs__header-row {
  display: grid;
  grid-template-columns: 1fr 52px 1fr;
}
.gd-vs__col-head {
  padding: 14px 18px;
  font-weight: 700;
  font-size: 0.95rem;
  text-align: center;
  color: var(--ink);
  font-family: inherit;
}
.gd-vs__col-head--g { background: linear-gradient(135deg, #FEF0D0, #FDE8D4); }
.gd-vs__col-head--r { background: linear-gradient(135deg, #EAE0F5, #DDD0EE); }
.gd-vs__col-head--d { background: #F7F5FB; }

/* Content rows */
.gd-vs__row {
  display: grid;
  grid-template-columns: 1fr 52px 1fr;
  border-top: 1px solid #F0EEF6;
}
.gd-vs__cell {
  padding: 14px 18px;
  font-size: 0.9rem;
  color: var(--ink-mid);
  font-family: inherit;
  background: #FAFAFA;
}
.gd-vs__cell-lbl {
  display: block;
  font-size: 0.68rem;
  font-weight: 700;
  letter-spacing: 0.09em;
  text-transform: uppercase;
  margin-bottom: 4px;
}
.gd-vs__cell--g .gd-vs__cell-lbl { color: var(--peach); }
.gd-vs__cell--r .gd-vs__cell-lbl { color: var(--lav); }
.gd-vs__cell--d {
  display: flex;
  align-items: center;
  justify-content: center;
  font-size: 0.72rem;
  font-weight: 700;
  color: var(--ink-soft);
  background: #F7F5FB;
  padding: 0;
}

/* Mobile: stack columns */
@media (max-width: 560px) {
  .gd-vs__header-row,
  .gd-vs__row {
    grid-template-columns: 1fr;
  }
  .gd-vs__col-head--d,
  .gd-vs__cell--d { display: none; }
  .gd-vs__cell--r { border-top: 1px solid #F0EEF6; }
}
</style>

<div class="gd-vs">
  <!-- Lifecycle bar -->
  <div class="gd-vs__lifecycle">
    <div class="gd-vs__phase gd-vs__phase--a">
      <span class="gd-vs__phase-lbl">Design &amp; build</span>
      Configure tools, permissions, constraints
      <span class="gd-vs__phase-note">← Guardrails live here</span>
    </div>
    <div class="gd-vs__phase gd-vs__phase--b">
      <span class="gd-vs__phase-lbl">Deploy</span>
      Agent enters production environment
    </div>
    <div class="gd-vs__phase gd-vs__phase--c">
      <span class="gd-vs__phase-lbl">Runtime</span>
      Agent operates across systems
      <span class="gd-vs__phase-note">← Remediations live here</span>
    </div>
  </div>
  <!-- VS comparison -->
  <div class="gd-vs__card">
    <div class="gd-vs__header-row">
      <div class="gd-vs__col-head gd-vs__col-head--g">Guardrails</div>
      <div class="gd-vs__col-head gd-vs__col-head--d"></div>
      <div class="gd-vs__col-head gd-vs__col-head--r">Remediations</div>
    </div>
    <div class="gd-vs__row">
      <div class="gd-vs__cell gd-vs__cell--g">
        <span class="gd-vs__cell-lbl">When</span>
        Configured at design time, before deployment
      </div>
      <div class="gd-vs__cell gd-vs__cell--d">vs</div>
      <div class="gd-vs__cell gd-vs__cell--r">
        <span class="gd-vs__cell-lbl">When</span>
        Triggered at runtime, in response to observed behaviour
      </div>
    </div>
    <div class="gd-vs__row">
      <div class="gd-vs__cell gd-vs__cell--g">
        <span class="gd-vs__cell-lbl">What</span>
        Define permitted behaviour — tools, data, actions in scope
      </div>
      <div class="gd-vs__cell gd-vs__cell--d"></div>
      <div class="gd-vs__cell gd-vs__cell--r">
        <span class="gd-vs__cell-lbl">What</span>
        Counteract behaviour that deviates from policy or is misaligned with intent
      </div>
    </div>
    <div class="gd-vs__row">
      <div class="gd-vs__cell gd-vs__cell--g">
        <span class="gd-vs__cell-lbl">How</span>
        System prompts, tool restrictions, validators, permission scopes
      </div>
      <div class="gd-vs__cell gd-vs__cell--d"></div>
      <div class="gd-vs__cell gd-vs__cell--r">
        <span class="gd-vs__cell-lbl">How</span>
        Session interruption, tool blocking, context flagging, human escalation
      </div>
    </div>
    <div class="gd-vs__row">
      <div class="gd-vs__cell gd-vs__cell--g">
        <span class="gd-vs__cell-lbl">Limitation</span>
        Cannot observe or respond to dynamic behaviour across systems at runtime
      </div>
      <div class="gd-vs__cell gd-vs__cell--d"></div>
      <div class="gd-vs__cell gd-vs__cell--r">
        <span class="gd-vs__cell-lbl">Limitation</span>
        Requires behavioural observability across the full workflow — not just within one platform
      </div>
    </div>
  </div>
</div>

> _Guardrails define what should happen. Remediations address what actually happens when behavior deviates — in real time, across systems, in the context of a live workflow._

Neither replaces the other. Well-designed guardrails reduce the surface area that remediations need to cover. Effective remediations catch the cases that guardrails by their nature as design-time controls cannot anticipate.

### Geordie's Response - Beam

Geordie's Beam is designed for exactly this gap: contextual engineering and policy that governs agents across both configuration and behavioral risk. Beam applies proactively, following the workflow rather than stopping at the platform boundary, so governance remains coherent whether an agent is contained within a single system or operating across several.
