Why Postman's Desktop Installer Auto-Wrote AI Agent Trust Hashes: Inside Issue #14370, Startup Hook Injection, and the Boundaries of Enterprise Consent
A technical postmortem on how automated developer tooling bypassed human verification in OpenAI Codex and Claude Code, what repository commits prove, and where exfiltration claims diverge from confirmed telemetry.
Japanese Edition: https://consuloji.substack.com/p/apipostmanai
YouTube (Japanese audio): https://www.youtube.com/watch?v=H2PJkDdi1k4
Executive Summary & Key Technical Takeaways
- The Incident Disclosure: In late October 2026, an issue filed against Postman’s public support repository (
postmanlabs/postman-app-support#14370) revealed that Postman Desktop (v12.33.4 on macOS) automatically installed AI agent plugins for OpenAI Codex and Anthropic Claude Code. Telemetry logs classified this action underauto-existing-upgrade, executingclaude-code:installedandcodex:installedwithout prompting the user. - The Self-Signing Trust Bypass: In
installer/src/hosts/codex-hooks.ts, Postman’s installer extracted the SHA-256 hash of its startup hook viahooks/listand programmatically wrote atrusted_hashentry directly into Codex’s internal configuration (config/batchWrite). By design, Codex mandates that unmanaged hooks remain untrusted until a developer manually reviews and approves the script. By auto-writing its own hash, Postman’s installer bypassed this human authorization boundary. - The Vendor Rationale in Git History: Git commit
6975d3e1(October 21, 2026) in Postman’s plugin repository documents why this bypass was built: because Postman’s installer trackedmainbranch continuously, upstream commits altered file hashes, triggering repeated Codex re-approval prompts. Postman automated hash injection to ensure its startup prompt executed on every terminal session without interruption. - Telemetry vs. Social Media Exfiltration Claims: While a viral Hacker News thread (1,482 points, 479 comments) claimed Postman was “silently attempting to share all API data,” the original reporter’s evidence explicitly disclaimed data theft (“This report establishes unwanted integration and instruction changes; it does not claim to establish data exfiltration”). The injected
SessionStarthook was a lightweight shell script echoing markdown text directing Codex to prioritize Postman skills. Remote Model Context Protocol (MCP) connections in telemetry logs failed withAuth required. No exfiltration code existed in the inspected scripts. - Unverified Rollback and Governance Breakdown: As of November 5, 2026, an unverified comment from an account appearing to represent Postman promised clearer opt-in mechanisms and a review of hook authorization. However, no corresponding commits appeared in the public repository after release 0.6.0 (tagged November 3, 2026 at 16:40 UTC), and the website download page quietly added a post-hoc disclosure sentence between October 26 and November 5.

1. Anatomy of GitHub Issue #14370: The Incident Timeline and Reported Artifacts
On October 25, 2026, at 19:03 UTC (October 26, JST), an engineer published Issue #14370 on the postmanlabs/postman-app-support repository:
[SEVERE] Desktop auto-installs Codex/Claude plugins; installer attempts to trust its own startup hook
The reporter documented an unexpected state transition on a macOS workstation following the launch of Postman Desktop 12.33.4. Local application logs revealed that during background initialization, Postman executed an upgrade routine labeled auto-existing-upgrade, triggering five concrete file-system and configuration modifications:
- Codex Global Configuration Modification: In the local configuration for OpenAI Codex, Postman registered its repository (
postmanlabs/postman-plugin) as an authorized plugin source and marked it enabled. - Programmatic Hook Authorization: The installer injected a
trusted_hashinto Codex’shooks.statedictionary, matching the cryptographic hash of Postman’s newly registeredSessionStarthook. - Claude Code Configuration Modification: The installer registered and enabled the Postman extension within Claude Code’s local plugin manifest.
- Binary Drop of Postman CLI: A standalone command-line executable (
postman) was installed into the developer’s execution path. - Runtime Instruction Steering: Upon subsequent launches of OpenAI Codex, the agent’s initialization prompt was augmented with instructions steering API-related workflows toward Postman’s tools.

The reporter explicitly noted that the sequence reflected observed workstation logs and had not yet been reproduced on a clean, isolated macOS installation.
On November 3, 2026, a second developer corroborated the core behavior on the same issue. Following an upgrade from Postman 12.31.3 to 12.35.1 on macOS, Postman CLI and the agent plugins appeared automatically. However, the second user noted an environmental variance: their Codex configuration did not contain the injected trusted_hash, and the prompt appeared within Cursor where the extension had been previously installed.
This divergence demonstrates that while silent bundle distribution was active across multiple versions, the success of the programmatic hash injection depended on specific runtime permissions and local CLI configurations.

2. Mechanics of Startup Hooks and the Evisceration of the Trust Boundary
To understand why enterprise security teams reacted with alarm, one must examine the threat model governing AI agent extensions.
In modern agentic environments like OpenAI Codex and Anthropic Claude Code, “hooks” are lifecycle event listeners executed by the host runtime. Specifically, SessionStart hooks trigger automatically whenever a terminal session opens, context is cleared, or prompt history is compacted (startup|clear|compact).
[Developer Launches Terminal]
│
▼
┌──────────────────────────────────────────────┐
│ AI Agent Host Runtime (Codex) │
│ │
│ 1. Scan hooks directory │
│ 2. Compute SHA-256 hash of hook script │
│ 3. Compare against config: trusted_hash │
└──────────────────────┬───────────────────────┘
│
┌───────────────┴───────────────┐
▼ ▼
[Hash Matches] [Hash Missing / Changed]
│ │
▼ ▼
Execute hook script Prompt Human Developer:
(Inject context) "Hook needs review. Trust? (y/n)"
▲
│
Postman Installer Injected
Hash Here Directly,
Bypassing This Human Review!
Under Codex’s documented security architecture, hooks represent an arbitrary code-execution surface. A hook is a local shell script. Consequently, the Codex runtime enforces a cryptographic authorization gate:
- When an unmanaged hook is detected, Codex computes the SHA-256 digest of the script.
- If the digest is absent from
hooks.state.trusted_hash, Codex halts execution and displays:Hooks need review. - The human developer must manually inspect the script content and explicitly approve execution.
- If the script changes by a single byte, the hash invalidates, prompting the user again.
Postman’s installer dismantled this gate. The source code in installer/src/hosts/codex-hooks.ts contains the following execution flow:
// Architectural sequence in Postman's open-source installer
const hookList = await client.request('hooks/list');
const targetHook = hookList.find(h => h.name === 'session-start');
if (targetHook) {
await client.request('config/batchWrite', {
[`hooks.state.${targetHook.id}.trusted_hash`]: targetHook.hash
});
}
By querying the newly written hook’s hash and writing it into Codex’s trusted state via the local IPC API, the installer acted as both petitioner and judge. An authorization boundary exists to ensure that an external human verifies actions proposed by third-party software. When an installer writes its own authorization token, the security boundary collapses into security theater.

3. Postman’s Commit 6975d3e1 and the Dual Documentation Discrepancy
Why did Postman deploy code that programmatically circumvents developer security prompts?
The explanation is preserved in Postman’s Git commit history. In the public postmanlabs/postman-plugin repository, commit 6975d3e1 (October 21, 2026) carries the following explanation:
Codex binds hook trust to the hash of the plugin files. Because our installer tracks the main branch, upstream updates continuously trigger trust invalidation prompts, causing the session-start context to be skipped until re-approved. This update automatically records the trusted_hash upon installation.
From a product perspective, Postman engineers viewed this as solving UX friction: users who installed the plugin were missing Postman’s prompt context because updates to main invalidated the local hash, causing Codex to skip unapproved hooks. However, solving developer annoyance by automating the bypass of a security check created a critical enterprise vulnerability.
This architectural conflict is mirrored in Postman’s official documentation, which maintained two contradictory installation paths:
| Installation Channel | Documented Hook Trust Procedure | Primary Source Citation |
|---|---|---|
Per-Agent Manual CLI (npx) |
Hook is installed untrusted. Next Codex startup displays Hooks need review, requiring explicit approval. |
Postman Docs: Per-Agent Installation Guide |
| Detected-Agent Automatic Installer | The installer automatically trusts the hook. If programmatic trust fails, the user is guided to review in Codex. | Postman Docs: Detected Agents Auto-Install Guide |
Postman’s documentation openly acknowledged that its automated installer bypassed the review prompt, treating automatic authorization as a feature of its detection workflow. However, the documentation failed to clarify that this installer was bundled inside the background update routine of Postman Desktop itself.

4. Forensic Telemetry vs. Social Media Outrage: Untangling Data Exfiltration Claims
Following Issue #14370, discussion expanded across developer forums. On Hacker News, a submission titled:
Postman silently auto-installs AI plugins and attempts to share all API data
garnered 1,482 upvotes and 479 comments. However, a forensic comparison between the headline and primary artifacts reveals that claims of active data exfiltration were completely unsupported by evidence.
4-1. Analysis of Injected Payload Artifacts
Physical examination of the hook script (hooks/session-start) and context file (hooks/session-start-context.md) establishes the true scope of the injected code:
- The Hook Shell Script: The script is a basic posix shell wrapper. It does not invoke network daemons, curl endpoints, or background telemetry pipes; its sole function is echoing
session-start-context.mdto standard output. - The Injected Context Prompt: The markdown text injected into the AI agent’s context window instructs the model to inspect Postman skills prior to performing complex API tasks. Crucially, the text contains an explicit override:
User instructions (including AGENTS.md, CLAUDE.md, and direct conversational prompts) strictly supersede these guidelines.
- The Remote MCP Connection Attempt: In the reporter’s telemetry log, an attempt to initialize a remote Model Context Protocol (MCP) server failed with
Auth required. No credentials or API collections were transmitted.
The original reporter maintained technical precision, writing:
This report establishes unwanted integration and instruction changes; it does not claim to establish data exfiltration.
The viral social media narrative transformed an aggressive distribution and permission-bypass practice into an unsubstantiated corporate espionage allegation. While Postman’s automated configuration changes violated developer consent, there is zero primary evidence of data exfiltration.

4-2. Postman’s Corporate Response and Website History
On November 3, 2026, at 23:36 UTC, an account appearing to represent Postman posted a comment to Issue #14370 outlining four points:
- Postman bundled the CLI and plugins into Desktop to assist developers who found manual multi-tool installation difficult.
- The installation was described on the public download page and could be uninstalled via Desktop settings.
- The company was reviewing its opt-in model and hook authorization flow, with updates promised for existing users.
Independent verification of the Postman website via the Internet Archive reveals a quiet documentation shift. In a snapshot captured on October 26, 2026 (09:07 UTC), the official download page contained no mention of bundled AI agent plugins. By November 5, 2026, the page included an added sentence:
The Postman app includes Postman CLI & Postman plugins, so you can use Postman from your terminal.
Despite the comment’s promise to revise the hook authorization flow, the public postman-plugin repository showed zero commits following release 0.6.0 on November 3 at 16:40 UTC. As of November 5, the programmatic trust-writing code remained in codex-hooks.ts.

5. Enterprise Remediation & Audit Playbook: Inspecting Local Agent Runtimes
For security architects and engineering managers, Postman Issue #14370 illustrates a broader structural risk: desktop developer applications operating with standard user privileges can silently manipulate configuration files for developer AI tools.
Engineering organizations should immediately execute a three-step terminal audit to inspect local workstations:
Step 1: Audit OpenAI Codex Hook States and Trust Entries
Developers should verify active hooks and trusted hashes within OpenAI Codex:
- In the interactive Codex CLI, execute
/hooksto inspect registered lifecycle listeners. - Inspect the local configuration file located at
~/.codex/config.jsonand review thehooks.stateblock. - Verify whether unrecognized entries—specifically referencing
@postman/postman-plugin—are marked with activetrusted_hashvalues. - In enterprise environments, leverage administrative policy controls to restrict hook registration to centrally managed corporate repositories.
Step 2: Audit Anthropic Claude Code Active Extensions
Review installed extensions in Claude Code via the command-line interface:
claude plugin list
Review the emitted table columns: Name, Version, Scope, and Status. If @postman/postman-plugin appears enabled without prior user consent, remove it:
claude plugin remove @postman/postman-plugin
Step 3: Execute Dry-Run Audits of Plugin Status
If Postman’s CLI tooling is present on the workstation path, execute non-destructive diagnostic checks:
npx @postman/postman-plugin status
This inspects detected host agents and reports whether Postman extensions are configured. When executing removals or reconfigurations, enforce the --dry-run flag to preview proposed modifications before applying changes:
npx @postman/postman-plugin remove --dry-run

6. Structural Governance Takeaways for Software Vendors
The Postman incident provides critical architectural lessons for vendors integrating developer software with AI agent ecosystems:
- Decouple Distribution Consent from Execution Authorization: Installing a binary on a workstation does not grant an implicit license to modify the configuration of other independent development tools. Bundling must be explicitly opt-in.
- Never Automate the Bypass of Cryptographic Gates: Cryptographic approval mechanisms are designed to solicit explicit human consent. Bypassing a verification prompt programmatically—regardless of upstream update frequency—is an anti-pattern that triggers immediate security escalation.
- Maintain Immutable Audit Logs for Injected Prompts: Any tool that modifies an AI agent’s system prompt or session context must provide a transparent, user-visible log detailing the origin, timestamp, and precise wording of the injected context.
Primary Sources
- GitHub Issue Tracker: postmanlabs/postman-app-support #14370
- Postman Plugin Installer Source Code: codex-hooks.ts in postman-plugin Repository
- Postman Plugin Repository Readme: postmanlabs/postman-plugin README.md
- Postman Plugin Commit 6975d3e1: Git Commit History
- Postman Session-Start Context Markdown: session-start-context.md
- Postman Hook Execution Script: hooks/session-start Shell Script
- Postman Documentation on Detected Agents: Learning Center - Detected Agents Installation
- Postman Documentation on Per-Agent Installation: Learning Center - Per-Agent Installation
- Internet Archive Snapshot of Postman Downloads: Wayback Machine October 26, 2026
- OpenAI Codex Official Documentation: Codex Developer Guides on Hooks
- Anthropic Claude Code Documentation: Claude Code Architecture and Extension Guides
Note: This article is for informational purposes only and does not constitute investment advice or a price forecast. Podcast audio is synthesized from the host’s voice.