Skip to main content

Letta EUVDEUVD-2026-104692

| CVE-2026-77936 CRITICAL
Initialization of a Resource with an Insecure Default (CWE-1188)
2026-10-20 VulnCheck GHSA-g524-hhf9-5x95
9.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Discover exposed Letta API/Postgres port
  2. Exploit
    Send unauthenticated POST /v1/tools/run or connect with default DB creds
  3. Execution
    Execute arbitrary Python or COPY PROGRAM OS command
  4. Impact
    Full host/data compromise

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V13 - Configuration Secure default settings
Exploitation Conditions

Exploitation requires the target to be deployed using Letta's shipped compose.yaml (versions through 0.16.8) with LETTA_SERVER_SECURE left unset - which is the default - so the password middleware is never registered and every API route is unauthenticated; the same compose file also publishes a PostgreSQL superuser port with default credentials. The attacker needs network reachability to the Letta HTTP API (POST /v1/tools/run, /v1/admin) or to the exposed Postgres port. Limiting factors: the instance must be network-accessible to the attacker (internet-facing or shared network), and an operator who sets LETTA_SERVER_SECURE, changes the DB credentials, or does not expose the Postgres port is not vulnerable via that path; no user interaction or authentication is otherwise needed against the default configuration.

Impact

This is a genuine high-priority issue, not an inflated-CVSS artifact. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N with VC:H/VI:H/VA:H) describes unauthenticated, network-reachable, low-complexity full compromise, and the description confirms three independent paths to code/command execution (arbitrary Python via POST /v1/tools/run, admin user management via /v1/admin, and OS command execution via PostgreSQL COPY PROGRAM with default superuser credentials). Publicly available exploit code exists (POC=YES) and the issue was reported by VulnCheck, reinforcing that exploitation is practical rather than theoretical. No EPSS score was provided in the input, so a quantitative exploitation-probability signal is MISSING and cannot be compared against the POC signal. The CVE is NOT listed in CISA KEV in the provided data, so there is no evidence of confirmed active exploitation - this is POC availability, which is a distinct and weaker signal than in-the-wild use. No SSVC decision data was provided. The one tempering factor: exploitation depends on the vulnerable default Docker Compose deployment being exposed to a reachable network, so real-world risk scales with how many operators run the shipped compose.yaml on internet-facing or untrusted-LAN hosts.

Exploit ScenarioDerived

A remote attacker who can reach a Letta instance deployed via the shipped compose.yaml (with LETTA_SERVER_SECURE unset) sends an unauthenticated POST to /v1/tools/run and executes arbitrary Python on the server, or connects directly to the exposed superuser PostgreSQL port using default credentials and runs OS commands via COPY PROGRAM. No authentication, user interaction, or special privileges are required, and public exploit code is already available, lowering the barrier to opportunistic attacks.

Monitor Track and reassess. Why: Vendor states no customer action required.
No patch listed yet 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 20, 2026

Unauthenticated remote code execution and full administrative takeover affect Letta deployments through 0.16.8 that use the project's shipped compose.yaml, because the file leaves LETTA_SERVER_SECURE unset so the password middleware is never registered and every REST API route is reachable without credentials. A network-positioned attacker can therefore invoke POST /v1/tools/run to execute arbitrary Python, manage users via /v1/admin, and - through the same compose file's published PostgreSQL superuser port with default credentials - run operating-system commands via COPY PROGRAM. Publicly available exploit code exists and the issue has been cataloged by VulnCheck, though it is not confirmed actively exploited (CISA KEV); exploitation requires only that the instance be network-reachable in its default configuration, with no authentication or user interaction needed.

RemediationAI

No vendor-released patch identified at time of analysis - the advisory covers Letta through 0.16.8 and no fixed version is confirmed in the available data - so remediation centers on removing the insecure defaults the compose file introduces, per the VulnCheck advisory (https://www.vulncheck.com/advisories/letta-through-0.16.8-insecure-default-configuration-unauthenticated-api-and-postgresql-access) and the upstream references (https://github.com/letta-ai/letta/blob/1131535716e8a31c9a437f8695e25ac98f203a24/compose.yaml#L17 and https://github.com/letta-ai/letta/blob/1131535716e8a31c9a437f8695e25ac98f203a24/letta/server/rest_api/app.py#L799). Set LETTA_SERVER_SECURE to a truthy value and supply a strong LETTA_SERVER_PASSWORD so the password middleware is actually registered - note this breaks any existing unauthenticated client integrations that relied on open access. Replace the PostgreSQL default superuser credentials with a strong, unique password and create a non-superuser application role so COPY ... FROM PROGRAM is unavailable to the service account. Remove the published 5432 mapping from compose.yaml entirely (or bind it to 127.0.0.1) so the database is reachable only on the container network; the trade-off is that external DB tooling must then go through a bastion or docker exec. As an interim compensating control, restrict network access to the Letta HTTP API (ports 8283 and any exposed admin surface) with firewall rules, a reverse proxy requiring authentication, or a VPN, which limits exposure to trusted clients but leaves the underlying missing-auth defect in place. Where possible, upgrade past 0.16.8 once a release addresses the defaults, and verify LETTA_SERVER_SECURE and the DB credential state after every compose-based redeployment, since the insecure defaults are re-applied by the shipped file.

Affected VersionsENISA

letta 0 ≤0.16.8

Affected Packages

euvd letta no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Letta (formerly MemGPT) is a Python agent framework whose server component is a FastAPI/Starlette application; in letta/server/rest_api/app.py (referenced at line 799) the password authentication middleware is conditionally added only when the LETTA_SERVER_SECURE environment variable is truthy. The distributed compose.yaml (referenced at line 17) never sets that variable, so the default deployment registers no auth middleware at all and every route - including the tool-execution endpoint POST /v1/tools/run and the administration endpoints under /v1/admin - is served anonymously. The root cause is CWE-1188 (Insecure Default Initialization of Resource): security is opt-in rather than opt-out, so the out-of-the-box configuration is the vulnerable one. The same compose file compounds the problem by publishing the PostgreSQL superuser port with default credentials, giving attackers a second, independent path to the backing store; PostgreSQL's COPY ... FROM PROGRAM primitive turns that database access into arbitrary OS command execution on the database container. The combination yields confidentiality, integrity, and availability impact across the whole stack, matching the assessed CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (unauthenticated, network-reachable, no user interaction). Affected products are captured by the CPE cpe:2.3:a:letta-ai:letta:*:*:*:*:*:*:*:* as described below.

Know when Letta gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (VulnCheck) PRIMARY 9.3 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.8 CRITICAL

Default compose config leaves the API unauthenticated and reachable over the network with no user interaction (AV:N/AC:L/PR:N/UI:N), yielding arbitrary code/OS execution and full confidentiality, integrity, and availability loss.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Letta through 0.16.8 ships a compose.yaml that does not enable LETTA_SERVER_SECURE, so the password middleware is never added and all API routes are unauthenticated, and it exposes a superuser PostgreSQL port with default credentials. Remote attackers can execute arbitrary Python via POST /v1/tools/run, manage /v1/admin users, or run OS commands via COPY PROGRAM.

Technical POC Analysis

CWE-1188: Initialization of a Resource with an Insecure Default.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Letta deployments running the project's shipped compose.yaml through version 0.16.8 can be taken over completely by anyone who can reach them over the network, because the default configuration leaves the server's authentication setting unset and exposes a database port with default superuser credentials. That gives an outside party the ability to run arbitrary code, create or seize administrator accounts, and execute operating-system commands on the host - meaning full loss of confidentiality, integrity, and control over any affected instance. Leadership should care because these instances are typically stood up quickly for AI agent pilots and may hold API keys, model credentials, and production data, and there is currently no vendor patch to fall back on, only configuration hardening.

Business Impact: Severe
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: set LETTA_SERVER_SECURE so the password middleware is registered on every instance; stop publishing the PostgreSQL superuser port and replace default database credentials; place Letta and its database behind network segmentation with no direct internet exposure; restrict /v1/tools/run and /v1/admin to trusted administrative networks; monitor endpoint and database access logs for anomalous invocations; rotate all credentials and keys reachable from affected hosts.

Threat Intelligence Overview

EPSS Score
0.5%
Top 61% exploitable
Prevalence
Low
niche open-source AI agent framework, limited production deployment footprint
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.5%
Patch available No
Active threat No
Deciding rule
Vendor states no customer action required
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

66
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Related Vulnerabilities in Letta Authentication and Information Disclosure Flaws

View all 3

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy