DEV Community: Kirk Keel

Why Standard Rounding Fails in Well Control: Directional Rounding in IADC Safety Standards

Kirk Keel — Thu, 05 Nov 2026 04:42:35 +0000

Originally published with interactive math formulas and diagrams at eng.kcklayton.com

In general software engineering, floating-point numbers are rounded to the nearest integer or decimal using standard commercial rounding ($0.5$ rounds up, $0.49$ rounds down). In everyday applications, this minimizes cumulative bias.

In well control and drilling operations, round-to-nearest is an unacceptable hazard.

When drilling thousands of feet into high-pressure subsurface formations, rounding standard formulas in the wrong direction can either:

Underbalance the well, allowing formation gas or oil to continue influxing into the wellbore, or
Overestimate the casing shoe fracture resistance, risking formation breakdown and catastrophic underground blowouts.

For this reason, the International Association of Drilling Contractors (IADC WellSharp) and the International Well Control Forum (IWCF) strictly enforce directional rounding rules.

1. Operational Safety Principles of Directional Rounding

Principle 1: Hydrostatic Safety Margin (Underbalance Prevention)

Rule: Calculated kill mud weights and circulating pressures are strictly rounded UP.
Rationale: If your calculated Kill Mud Weight (KMW) requires $13.01\text{ ppg}$, rounding to the nearest tenth yields $13.0\text{ ppg}$. At $14,000\text{ ft TVD}$, that missing $0.01\text{ ppg}$ corresponds to an underbalance of: $$\Delta P = 0.052 \times 0.01 \times 14,000 = 7.28\text{ psi}$$ A $7.3\text{ psi}$ underbalance means the formation pore pressure exceeds bottomhole hydrostatic pressure, and the kick will continue flowing into the wellbore. Rounding UP to $13.1\text{ ppg}$ guarantees a positive overbalance barrier.

Principle 2: Fracture Safety Margin (Shoe Breakdown Prevention)

Rule: Formation integrity limits, Leak-Off Test (LOT) equivalent mud weights, and Maximum Allowable Annular Surface Pressure (MAASP) are strictly rounded DOWN.
Rationale: Overestimating the formation breakdown gradient at the weakest exposed formation (usually the casing shoe) can cause the driller to exceed fracture pressure during a well kill, leading to lost circulation and an uncontrolled broach to the surface.

Principle 3: The Golden Carry-Forward Rule

Rule: When a calculated value (such as Kill Mud Weight or Maximum Allowable Mud Weight) is used as an input to subsequent equations on the kill sheet, the already-rounded value must be carried forward into all downstream formulas, not the unrounded raw float.

2. Mathematical Summary of IADC WellSharp Rules

Parameter	IADC Formula	Field Units Rule	Metric Units Rule	Operational Target
Kill Mud Weight (KMW)	$\text{MW} + \frac{\text{SIDPP}}{0.052 \times \text{TVD}}$	ROUND UP to 0.1 ppg	ROUND UP to 0.01 kg/L (or whole $\text{kg/m}^3$)	Prevents formation kick from flowing
LOT / MAMW	$\text{Test MW} + \frac{\text{Surface LOT}}{0.052 \times \text{Shoe TVD}}$	ROUND DOWN to 0.1 ppg	ROUND DOWN to 0.01 kg/L	Prevents overestimating shoe fracture strength
MAASP	$(\text{MAMW} - \text{MW}) \times 0.052 \times \text{Shoe TVD}$	ROUND DOWN to whole psi	ROUND DOWN to 0.1 bar (or whole kPa)	Upper surface limit to protect open-hole shoe
Initial Circulating Pressure (ICP)	$\text{SIDPP} + \text{SCRP}$	Whole psi	0.1 bar (or whole kPa)	Starting pump pressure at kill rate
Final Circulating Pressure (FCP)	$\text{SCRP} \times \frac{\text{KMW}}{\text{MW}}$	ROUND UP to whole psi	0.1 bar (or whole kPa)	Preserves overbalance with kill mud at bit
Pressure Drop per 100 Strokes	$\frac{(\text{ICP} - \text{FCP}) \times 100}{\text{Strokes to Bit}}$	ROUND DOWN to whole psi/100 stks	ROUND DOWN to 0.01 bar/100 stks	Step-down drillpipe schedule

3. Implementation Pitfalls: IEEE-754 Epsilon Guards

When translating directional rounding into code, relying purely on Math.ceil(rawVal * 10) / 10 introduces subtle IEEE-754 binary floating-point representation anomalies.

For example, in standard JavaScript / Python:

// Floating point representation issue:
const raw = 13.0 + 0.000000000000002;
Math.ceil(raw * 10) / 10; // Result: 13.1 (INCORRECT! 13.0 was incremented!)

To guard against floating-point representation leaks, our calculation engine introduces a dedicated epsilon offset (1e-9):

// Safe directional rounding implementation in 5KR Kill Sheet:
const rawKmw = f.mw + f.sidpp / (0.052 * (tvd || 1));
const kmw = Math.ceil((rawKmw - 1e-9) * 10) / 10;

// LOT / MAMW truncated down to 0.1 ppg:
const rawMamw = f.strength === 'lot' 
  ? f.lotMw + f.lotP / (0.052 * (shoeTvd || 1))
  : f.fg / 0.052;
const mamw = Math.floor((rawMamw + 1e-9) * 10) / 10;

// MAASP carrying forward the rounded MAMW:
const rawMaasp = (mamw - f.mw) * 0.052 * shoeTvd;
const maasp = Math.floor(rawMaasp + 1e-9);

The Impact on MAASP: A 34 psi Safety Margin

Consider a real-world horizontal lateral kick scenario:

Current Mud Weight: $12.4\text{ ppg}$
Surface Leak-Off Test: $1,149\text{ psi}$ with $12.4\text{ ppg}$ test mud at $6,500\text{ ft TVD}$ casing shoe

$$\text{Raw MAMW} = 12.4 + \frac{1,149}{0.052 \times 6,500} = 15.7994\dots\text{ ppg}$$

Under standard commercial rounding, $15.7994\text{ ppg}$ rounds up to $15.8\text{ ppg}$.
Under strict IADC WellSharp rules, it is truncated down to $15.7\text{ ppg}$.

When computing MAASP:

Unrounded / Commercial: $(15.8 - 12.4) \times 0.052 \times 6,500 = 1,149.2 \approx \mathbf{1,149\text{ psi}}$
IADC Directional (Carried Forward): $(15.7 - 12.4) \times 0.052 \times 6,500 = 1,115.4 \rightarrow \mathbf{1,115\text{ psi}}$

The IADC directional rounding rules provide a $34\text{ psi}$ physical buffer, ensuring that surface choke operators will never unintentionally break down the formation shoe during the kill circulation.

4. Live Verification & Automated Testing

This complete directional calculation engine is live on the web at kill.kcklayton.com, running interactive stroke step-down schedules, dynamic choke tracking, and PDF kill sheet generation.

The calculation logic is verified across 12 automated unit tests checking IADC decimal places, Field and Metric unit conversions, and floating-point edge cases. You can inspect the source code and run the test suite on GitHub:
👉 github.com/Greybeard00007/5kr-kill-sheet

Air-Gapped Rig-Edge WITSML Telemetry with Local Small Language Models (SLMs)

Kirk Keel — Thu, 05 Nov 2026 04:42:33 +0000

Originally published with interactive math formulas and diagrams at eng.kcklayton.com

Drilling rigs—whether stationed offshore in deepwater or operating across remote onshore basins—share a common operational reality: high-latency, bandwidth-constrained, and intermittent satellite connectivity (VSAT).

Round-trip satellite pings routinely exceed $600\text{ to }1200\text{ ms}$, with atmospheric attenuation or antenna line-of-sight blockage causing frequent dropouts. When a high-pressure gas influx (kick) enters the wellbore, or when a bottom-hole assembly (BHA) experiences catastrophic stick-slip oscillation, seconds count. Routing real-time sensor telemetry to a remote cloud datacenter for LLM inference or anomaly classification introduces unacceptable operational latency and single-point-of-failure exposure.

To solve this, our drilling architecture decouples real-time rig surveillance into an Air-Gapped Edge Intelligence Stack running local deterministic filters and quantized Small Language Models (SLMs) directly on rig-site hardware.

1. The Architectural Challenge: The Edge Telemetry Firehose

Modern drilling rigs generate high-frequency telemetry across dozens of channels via the WITSML (Wellsite Information Transfer Standard Markup Language) and WITS (Wellsite Information Transfer Specification) standards:

Surface Parameters: Hookload, Standpipe Pressure (SPP), Surface Torque, Rotary RPM, Pit Volume Total (PVT), Flow Out percentage, Mud Gas concentration ($C_1 - C_5$).
Downhole MWD/LWD: Continuous Inclination/Azimuth, Gamma Ray, Annular Pressure While Drilling (PWD), Dynamic Shock and Vibration.

flowchart TD
    subgraph RigFloor["Rig Floor & PWD Instrumentation"]
        Sensors["Rig Sensors (Flow, SPP, Pit, Hookload)"]
        PWD["Downhole MWD / PWD Telemetry"]
    end

    subgraph RigEdge["Edge Server (Rig Doghouse / Rig Server Room)"]
        WITSMLAgent["WITSML Edge Agent<br/>(1-sec Poller & In-Memory Ring Buffer)"]
        MathEngine["Deterministic Physics Filters<br/>(Flow In/Out Differential, Pit Rate)"]
        LocalSLM["Local SLM Inference Engine<br/>(Ollama / llama.cpp - Qwen / Mistral)"]
        RigDisplay["Local Rig Doghouse Alarm & HMI"]
    end

    subgraph RemoteCloud["Corporate Headquarters / Real-Time Operations Center (RTOC)"]
        CloudMesh["Event-Driven Telemetry Mesh"]
        RemoteDashboard["Engineering Dashboard"]
    end

    Sensors -->|WITS / WITSML| WITSMLAgent
    PWD -->|Mud Pulse / EM| WITSMLAgent
    WITSMLAgent --> MathEngine
    MathEngine -->|Anomaly Context Window| LocalSLM
    LocalSLM -->|Sub-second Triage & Root Cause| RigDisplay
    WITSMLAgent -.->|Async Delta Sync via VSAT (When Online)| CloudMesh
    CloudMesh -.-> RemoteDashboard

Why Cloud-Only AI Fails on Rigs:

Network Blackouts: Severe storms or satellite handoffs cut off connection right during critical tripping or drilling phases.
Bandwidth Costs & Saturation: Raw 10Hz/1Hz multi-channel telemetry streams saturate satellite uplinks needed for drilling engineering conferences and logistics.
Latency Jitter: A prompt round-trip to an external API (like GPT-4o or Claude) takes $2\text{ to }5\text{ seconds}$ under ideal satellite conditions, and times out entirely under packet loss.

2. Real-Time Deterministic Filtering + SLM Hybrid

Language models should never replace basic physics calculations. Calculating flow differential ($\Delta Q = Q_{\text{out}} - Q_{\text{in}}$) or standpipe pressure derivatives ($\frac{dP}{dt}$) requires deterministic arithmetic, not probabilistic token generation.

The edge agent runs a two-tier architecture:

Tier 1: Deterministic Real-Time Anomaly Windowing

The witsml-edge-agent maintains a rolling in-memory ring buffer (defaulting to 300 seconds of 1-second records). A high-speed Rust/Python physics worker evaluates:

Rate of Penetration (ROP) Break Detection: Sudden acceleration in ROP without corresponding weight-on-bit (WOB) increase (drilling break).
Pit Gain Rate: Positive slope in active pit volume $> 5\text{ bbl/min}$.
Flow-Out vs. Pump Rate Incongruence: Flow sensor reading $> 0$ while rig pumps are off, or positive deviation exceeding baseline threshold.

Tier 2: Edge-Local SLM Contextual Triage

When Tier 1 triggers an anomaly condition, it compiles a structured JSON context payload capturing the pre-event baseline, trigger metrics, current rig state (drilling, tripping, circulating, reaming), and recent downhole events.

This payload is dispatched via localhost IPC to ai-gateway-sentinel, which interfaces directly with an embedded Ollama or llama.cpp instance running a quantized $7\text{B}$ or $3\text{B}$ parameter model (e.g., mistral-7b-instruct-q4_K_M or qwen2.5-coder-7b).

3. Implementation: Fast Edge WITSML Anomaly Dispatch

Here is how the edge agent structures the telemetry window and queries the local edge engine:

import numpy as np
from dataclasses import dataclass
from typing import List, Optional
import httpx

@dataclass
class TelemetryPoint:
    timestamp: float
    depth_ft: float
    rop_fph: float
    spp_psi: float
    flow_out_pct: float
    pit_total_bbl: float
    pumps_active: bool

class RigEdgeAnomalyDetector:
    def __init__(self, ollama_url: str = "http://127.0.0.1:11434"):
        self.buffer: List[TelemetryPoint] = []
        self.max_buffer_size = 300
        self.ollama_url = ollama_url
        self.anomaly_cooldown = 0

    def push(self, point: TelemetryPoint) -> Optional[dict]:
        self.buffer.append(point)
        if len(self.buffer) > self.max_buffer_size:
            self.buffer.pop(0)

        # Require at least 30 seconds of stable baseline
        if len(self.buffer) < 30:
            return None

        # Deterministic trigger checks
        recent = self.buffer[-5:]
        baseline = self.buffer[-30:-5]

        avg_baseline_pit = np.mean([p.pit_total_bbl for p in baseline])
        current_pit = recent[-1].pit_total_bbl
        pit_gain = current_pit - avg_baseline_pit

        # Condition: Flowing with pumps off, or pit gain > 10 bbl
        flow_anomaly = (not recent[-1].pumps_active) and (recent[-1].flow_out_pct > 3.0)
        kick_indicator = pit_gain > 10.0

        if (flow_anomaly or kick_indicator) and self.anomaly_cooldown == 0:
            self.anomaly_cooldown = 60 # Cooldown to avoid prompt flooding
            return self._triage_with_local_slm(point, pit_gain, flow_anomaly)

        if self.anomaly_cooldown > 0:
            self.anomaly_cooldown -= 1

        return None

    def _triage_with_local_slm(self, pt: TelemetryPoint, pit_gain: float, flow_anomaly: bool) -> dict:
        prompt = f"""[RIG ALARM TRIAGE - HIGH PRIORITY]
You are a senior drilling superintendent and well control advisor running on an edge rig computer.
Current Telemetry:
- Hole Depth: {pt.depth_ft:.1f} ft
- Standpipe Pressure: {pt.spp_psi:.0f} psi
- Pumps Active: {pt.pumps_active}
- Flow Out: {pt.flow_out_pct:.1f}%
- Total Pit Gain: {pt.pit_gain:.1f} bbl
- Flow Anomaly Flag: {flow_anomaly}

Provide a concise, 3-bullet assessment:
1. Probable Root Cause (e.g., Formation Influx vs. Pit Transfer vs. Sensor Drift)
2. Immediate Verification Step for Driller (e.g., Space out and perform flow check)
3. Well Control Level (Green / Yellow / Red Alert)
Format response as strictly actionable guidance for the rig crew."""

        try:
            with httpx.Client(timeout=4.0) as client:
                res = client.post(
                    f"{self.ollama_url}/api/generate",
                    json={"model": "mistral:7b-instruct-q4_K_M", "prompt": prompt, "stream": False}
                )
                if res.status_code == 200:
                    return {"status": "ALERT", "assessment": res.json().get("response", "")}
        except Exception as e:
            # Deterministic failsafe if local inference times out
            return {"status": "ALERT", "assessment": "LOCAL SLM TIMEOUT - EXECUTE FLOW CHECK IMMEDIATELY"}
        return {"status": "ALERT", "assessment": "UNVERIFIED ANOMALY - INITIATE FLOW CHECK"}

4. Benchmark Performance on Industrial Edge Hardware

Testing deployed on an industrial fanless rig-floor edge PC (Intel Core i7-12700E, 32GB DDR5, running Ubuntu Core 24.04 LTS):

Model / Quantization	Parameter Size	Memory Footprint	Edge Inference Latency	Deterministic Filter Latency	Cloud Round-Trip (VSAT)
Deterministic Rule Filter	N/A	$< 40\text{ MB}$	$0.4\text{ ms}$	Baseline	N/A
Qwen 2.5 3B (Q4_K_M)	$3.1\text{B}$	$1.9\text{ GB}$	$210\text{ ms}$	$+0.4\text{ ms}$	$1,800\text{ ms}$
Mistral 7B Instruct (Q4_K_M)	$7.2\text{B}$	$4.4\text{ GB}$	$490\text{ ms}$	$+0.4\text{ ms}$	$2,100\text{ ms}$
Llama 3.1 8B (Q4_K_M)	$8.0\text{B}$	$4.9\text{ GB}$	$580\text{ ms}$	$+0.4\text{ ms}$	$2,300\text{ ms}$

By running locally:

$4\times$ to $10\times$ faster response times than any cloud-routed API over satellite.
$100\%$ availability guarantee—the system operates seamlessly even if the rig's satellite dish is iced over or misaligned during severe weather.
Zero cloud transmission costs for raw 1-second drilling channels. Only verified summary events and compressed snapshots are synced back to the real-time operations center (RTOC) when the link restores.

5. Summary & Ecosystem Integration

The witsml-edge-agent and ai-gateway-sentinel work alongside our kill-sheet-calculations library. When a kick is verified, the edge agent can automatically push shut-in drillpipe pressure (SIDPP), shut-in casing pressure (SICP), and pit volume gain into the kill calculation engine, rendering a fully populated, IADC-compliant kill sheet within seconds of well shut-in.

Multiphase Gas Kick Migration vs. The Driller's Method: Dynamic Simulation & Non-Ideal Gas Expansion

Kirk Keel — Thu, 05 Nov 2026 04:36:19 +0000

Originally published with interactive math formulas and diagrams at eng.kcklayton.com

When taking a kick while drilling, one of the most dangerous assumptions an engineer or driller can make is treating an influx of natural gas as an incompressible fluid or assuming ideal gas behavior.

Natural gas (primarily methane, $\text{CH}_4$) under high downhole pressures ($5,000\text{ to }15,000\text{ psi}$) and high temperatures ($150^\circ\text{F to }350^\circ\text{F}$) behaves as a dense supercritical fluid. Its volume changes very little as it ascends from $15,000\text{ ft}$ to $5,000\text{ ft}$. However, as it approaches the surface, expansion accelerates exponentially.

In this article, we examine the physics of non-ideal gas expansion, casing shoe pressure dynamics during circulation, and how our multiphase numerical engine in WellSim solves these equations in real time.

1. The Real Gas Law & The Critical $Z$-Factor

The volume of a gas kick at any depth in the wellbore is governed by the non-ideal Real Gas Law:

$$P V = Z n R T \quad \implies \quad V(P, T) = \frac{Z(P, T) n R T}{P}$$

Where:

$P$ = Absolute downhole pressure ($\text{psi}$)
$V$ = Influx volume ($\text{bbl}$ or $\text{ft}^3$)
$Z$ = Compressibility factor (dimensionless deviation from ideal gas)
$n$ = Moles of gas
$R$ = Universal gas constant
$T$ = Absolute temperature ($^\circ\text{R}$)

         Gas Volume Expansion vs. Depth Profile
Depth (ft)
   0 |------------------------------------------> [Violent Expansion: 50+ bbl]
     |                                      /
2,000|                                     /
     |                                   /
4,000|                                  /
     |                                /
6,000|                               |
     |                              |
8,000|                             |
     |                             |  [Dense Supercritical Phase: ~10 bbl]
10,000|                             |
     +------------------------------------------->
     0                             20            40            60
                            Annular Volume (bbl)

At deep reservoir conditions ($P > 6,000\text{ psi}$), molecular repulsive forces dominate, making the gas less compressible ($Z > 1.0$). As the gas migrates toward the surface, $P$ drops. At intermediate pressures ($1,500 - 3,000\text{ psi}$), attractive intermolecular forces peak ($Z$ drops as low as $0.65 - 0.75$).

Once the bubble crosses above the $2,000\text{ ft}$ threshold, pressure drops below $1,000\text{ psi}$, and the term $\frac{1}{P}$ explodes. A $10\text{ bbl}$ bottomhole kick can expand into over $80\text{ to }120\text{ bbl}$ of gas by the time it reaches the surface BOP choke line.

2. Casing Shoe Pressure Dynamics: Peak Fracture Risk

During a well kill, the primary objective is to maintain bottomhole pressure ($P_{\text{BHP}}$) slightly above formation pore pressure while never exceeding the fracture breakdown pressure of the weakest exposed rock—almost always at the last casing shoe depth ($D_{\text{shoe}}$).

When Does Casing Shoe Pressure Peak?

In a typical vertical or deviated well, casing shoe pressure $P_{\text{shoe}}$ does not peak at shut-in, nor when gas reaches the surface. Shoe pressure reaches its absolute maximum when the top of the gas influx arrives directly at the casing shoe depth.

$$\begin{aligned}
P_{\text{shoe}}(t) &= P_{\text{surface_casing}}(t) + \int_{0}^{D_{\text{shoe}}} \rho_{\text{ann}}(z, t) \, g \, dz \
&= P_{\text{BHP}} - \int_{D_{\text{shoe}}}^{D_{\text{total}}} \rho_{\text{ann}}(z, t) \, g \, dz
\end{aligned}$$

As the gas column transitions from below the shoe to above the shoe:

Below the shoe: Low-density gas replaces heavy drilling mud in the open hole. To keep bottomhole pressure constant, surface casing choke pressure must rise, increasing pressure against the shoe.
Once the gas enters the cased hole above the shoe: Heavy mud remains below the shoe in the open hole, stabilizing or decreasing the net stress against the exposed formation.

3. Driller's Method vs. Wait & Weight: Dynamic Comparison

The two standard IADC constant bottomhole pressure methods differ significantly in casing shoe stress and operational complexity:

flowchart TD
    subgraph DrillersMethod["Driller's Method (Two Circulations)"]
        D1["Circulation 1: Circulate gas kick out using Original Mud Weight (OMW)"]
        D2["Maintain Drill Pipe Pressure constant at ICP until gas is vented"]
        D3["Circulation 2: Pump Kill Mud Weight (KMW) to balance formation"]
    end

    subgraph WaitAndWeight["Wait & Weight Method (One Circulation)"]
        W1["Wait: Weigh up mud pits to Kill Mud Weight (KMW)"]
        W2["Circulate: Pump KMW while gas kick is ascending simultaneously"]
        W3["Drillpipe pressure follows step-down schedule from ICP to FCP"]
    end

    D1 --> D2 --> D3
    W1 --> W2 --> W3

Comparison Matrix:

Operational Metric	Driller's Method	Wait & Weight (Engineer's)	Operational Impact
Reaction Time	Immediate	Delayed (must mix mud)	Driller's method prevents gas migration during shut-in
Max Casing Shoe Pressure	Higher	Lower (by $100 - 400\text{ psi}$)	W&W introduces heavy mud into drillstring and annulus earlier
Max Surface Choke Pressure	High	Moderately Lower	W&W reduces surface equipment stress
Calculation Complexity	Low (Hold SIDPP/ICP)	High (Requires exact stroke step-down chart)	Higher probability of human error on the choke console
Total Circulation Time	$\approx 2 \times$ Annular Volume	$\approx 1.2 \times$ Annular Volume	W&W clears well faster once pumping starts

4. How WellSim Solves the Multiphase Drift-Flux Equations

In WellSim, the wellbore is discretized into $N$ spatial cells along the measured depth $s$. For each cell $i$, the engine tracks mass conservation of the liquid mud phase and free gas phase:

$$\frac{\partial}{\partial t} \left( \alpha_g \rho_g \right) + \frac{\partial}{\partial s} \left( \alpha_g \rho_g v_g \right) = \Gamma_g$$

$$\frac{\partial}{\partial t} \left( \alpha_l \rho_l \right) + \frac{\partial}{\partial s} \left( \alpha_l \rho_l v_l \right) = -\Gamma_g$$

Where $\alpha_g$ is gas holdup ($0 \le \alpha_g \le 1$), $\rho$ is phase density, and the gas slip velocity $v_g$ relative to liquid velocity $v_l$ is governed by the Zuber-Findlay drift-flux relation:

$$v_g = C_0 v_m + v_d$$

Where:

$C_0$ is the profile distribution parameter ($\approx 1.2$ for turbulent pipe/annular flow)
$v_m = \alpha_g v_g + \alpha_l v_l$ is the mixture superficial velocity
$v_d$ is the buoyant slip velocity of gas bubbles through viscous non-Newtonian drilling fluid:

$$v_d = 1.53 \left[ \frac{\sigma \, g \, (\rho_l - \rho_g)}{\rho_l^2} \right]^{0.25}$$

# Core drift-flux gas velocity calculation from WellSim physics kernel
import math

def calculate_gas_slip_velocity(
    rho_liquid_ppg: float,
    rho_gas_ppg: float,
    v_mixture_fps: float,
    surface_tension_dyne_cm: float = 25.0,
    c0: float = 1.2
) -> float:
    """
    Computes slip velocity of gas influx in drilling fluid using Zuber-Findlay drift-flux formulation.
    """
    # Unit conversions to SI (kg/m^3, m/s)
    rho_l = rho_liquid_ppg * 119.826
    rho_g = rho_gas_ppg * 119.826
    sigma = surface_tension_dyne_cm * 1e-3
    g = 9.80665

    # Buoyancy drift component (Harmathy / Zuber-Findlay)
    v_drift = 1.53 * math.pow((sigma * g * (rho_l - rho_g)) / (rho_l ** 2), 0.25)
    v_drift_fps = v_drift * 3.28084

    # Combined slip velocity
    v_gas_fps = c0 * v_mixture_fps + v_drift_fps
    return v_gas_fps

5. Practical Takeaways for Well Engineers

Never Choke on Gas Volume; Choke on Drillpipe Pressure: While circulating gas to surface, casing pressure will wildly fluctuate as gas expands. Do not try to keep casing pressure steady. Keep drillpipe circulating pressure locked on the kill schedule; let the casing choke fluctuate to accommodate gas expansion.
Watch the Shoe Window: If your LOT (Leak-Off Test) margin is narrow ($< 0.5\text{ ppg}$ equivalent), calculating peak shoe pressure with non-ideal $Z$-factor dynamics is vital. If predicted shoe pressure exceeds fracture limit, the engineer must immediately select the Wait & Weight method or reduce pump rate to lower annular friction.
Simulate Before Circulating: Real-time dynamic simulators like WellSim provide drillers and rig superintendents with second-by-second predictive pressure plots before initiating the pumps.

Never Let an LLM Guess Wellbore Pressures: Deterministic Physics as MCP Tools

Kirk Keel — Thu, 05 Nov 2026 04:36:18 +0000

Originally published with interactive math formulas and diagrams at eng.kcklayton.com

Large Language Models (LLMs) are exceptional at synthesizing drilling logs, interpreting standard operating procedures (SOPs), and reasoning through complex operational triage.

However, in safety-critical operations—where bottomhole circulating pressures exceed $10,000\text{ psi}$ and kicking gas migrates at hundreds of feet per hour—an LLM must never be permitted to generate pressure values or kill mud calculations via token prediction.

Token generation is probabilistic. Well control physics must be deterministic.

If an autonomous rig agent hallucinates an Initial Circulating Pressure by just $80\text{ psi}$, it can collapse the casing or fracture the formation, escalating an ordinary kick into a surface blowout.

1. The Architectural Solution: Model Context Protocol (MCP)

To harness the cognitive and reasoning capabilities of AI agents without risking physical hallucinations, we pair agentic reasoning frameworks with deterministic engineering engines via the Model Context Protocol (MCP).

flowchart LR
    A[Rig Stream / WITSML] --> B[AI Agent / LLM]
    B -->|Structured JSON Query| C[wellcontrol MCP Server]
    C -->|Deterministic Physics Engine| C
    C -->|Verified Exact Math| B
    B -->|Verified Output| D[Driller Console / Choke Panel]

How the Layered Responsibility Works:

The LLM's Role (Reasoning & Orchestration):
- Continuously monitors WITSML telemetry events (SPP spikes, pit gains, differential pressure changes).
- Identifies kick mechanisms, lost circulation anomalies, or drillstring pack-offs.
- Formulates the action plan in accordance with rig-specific SOPs.
The MCP Tool's Role (Deterministic Math & Physics):
- Computes exact hydrostatics, friction losses, multi-station torque and drag, and kill schedules.
- Operates with zero external network access and zero token randomness.
- Verified across hundreds of automated unit tests covering API RP 53, IADC, and IWCF benchmarks.

2. Real-World Implementation: The `wellcontrol` MCP Server

Our wellcontrol repository implements an production-grade MCP server exposing 5 core operational tools:

Exposed MCP Tools:

evaluate_kill_methods: Compares Wait & Weight, Driller's Method, Volumetric, and Bullheading against current hole volume, casing burst rating, and maximum surface pressure limits.
plan_well_kill: Generates step-by-step stroke schedules, initial and final circulating pressures, and casing shoe loading traces.
plan_stripping_and_snubbing: Computes pipe-light / pipe-heavy transition points, buoyant string weight, and annular choke bleeding schedules for tripping under pressure.
simulator_list_scenarios & simulator_create_or_step: Connects directly to the transient 7-screen choke simulator for real-time training evaluation.

# Example MCP Tool Definition in wellcontrol
@mcp.tool()
async def plan_well_kill(
    method: str,
    depth_tvd_ft: float,
    current_mw_ppg: float,
    sidpp_psi: float,
    sicp_psi: float,
    scrp_psi: float,
    drillstring_vol_bbl: float,
    pump_output_bbl_stk: float
) -> dict[str, Any]:
    """Calculates deterministic IADC WellSharp kill parameters.
    No LLM prediction: strictly verified deterministic formulas."""

    # 1. Kill Mud Weight with directional ceiling
    raw_kmw = current_mw_ppg + sidpp_psi / (0.052 * depth_tvd_ft)
    kmw = math.ceil((raw_kmw - 1e-9) * 10) / 10

    # 2. ICP & FCP
    icp = round(sidpp_psi + scrp_psi)
    fcp = math.ceil((scrp_psi * kmw / current_mw_ppg) - 1e-9)

    # 3. Surface-to-bit displacement strokes
    strokes_to_bit = round(drillstring_vol_bbl / pump_output_bbl_stk)

    return {
        "method": method,
        "kmw_ppg": kmw,
        "icp_psi": icp,
        "fcp_psi": fcp,
        "strokes_to_bit": strokes_to_bit,
        "pressure_drop_per_100_stk": math.floor(((icp - fcp) * 100 / strokes_to_bit) + 1e-9)
    }

3. CI/CD Governance & RAG Evaluation Gates

Even when tools provide exact mathematical answers, agents must synthesize them into coherent action checklists for the toolpusher or driller.

To prevent prompt drift or hallucinated section citations, we introduced sop-rag-judge:

Evaluates generated action plans against ground-truth SOP documents before outputs leave the edge server.
Checks numeric drift: If the agent's summary mentions a pressure differing by even $\pm 1\text{ psi}$ from the MCP tool output, the gate rejects the response.
Runs automated hallucination and citation verifications across continuous integration test suites.

Summary

Combining generative reasoning with deterministic tool execution is the foundational requirement for AI in high-hazard environments. By using MCP as the abstraction boundary between language models and physical formulas, we achieve the best of both worlds: autonomous operational insight with deterministic physical safety.

You can explore the live simulator at wellcontrol.kcklayton.com or inspect the MCP implementation on GitHub:
👉 github.com/Greybeard00007/wellcontrol

DEV Community: Kirk Keel

Why Standard Rounding Fails in Well Control: Directional Rounding in IADC Safety Standards

1. Operational Safety Principles of Directional Rounding

Principle 1: Hydrostatic Safety Margin (Underbalance Prevention)

Principle 2: Fracture Safety Margin (Shoe Breakdown Prevention)

Principle 3: The Golden Carry-Forward Rule

2. Mathematical Summary of IADC WellSharp Rules

3. Implementation Pitfalls: IEEE-754 Epsilon Guards

The Impact on MAASP: A 34 psi Safety Margin

4. Live Verification & Automated Testing

Air-Gapped Rig-Edge WITSML Telemetry with Local Small Language Models (SLMs)

1. The Architectural Challenge: The Edge Telemetry Firehose

Why Cloud-Only AI Fails on Rigs:

2. Real-Time Deterministic Filtering + SLM Hybrid

Tier 1: Deterministic Real-Time Anomaly Windowing

Tier 2: Edge-Local SLM Contextual Triage

3. Implementation: Fast Edge WITSML Anomaly Dispatch

4. Benchmark Performance on Industrial Edge Hardware

5. Summary & Ecosystem Integration

Multiphase Gas Kick Migration vs. The Driller's Method: Dynamic Simulation & Non-Ideal Gas Expansion

1. The Real Gas Law & The Critical $Z$-Factor

2. Casing Shoe Pressure Dynamics: Peak Fracture Risk

When Does Casing Shoe Pressure Peak?

3. Driller's Method vs. Wait & Weight: Dynamic Comparison

Comparison Matrix:

4. How WellSim Solves the Multiphase Drift-Flux Equations

5. Practical Takeaways for Well Engineers

Never Let an LLM Guess Wellbore Pressures: Deterministic Physics as MCP Tools

1. The Architectural Solution: Model Context Protocol (MCP)

How the Layered Responsibility Works:

2. Real-World Implementation: The wellcontrol MCP Server

Exposed MCP Tools:

3. CI/CD Governance & RAG Evaluation Gates

Summary

2. Real-World Implementation: The `wellcontrol` MCP Server