Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDiscover exposed Letta API/Postgres port
-
ExploitSend unauthenticated POST /v1/tools/run or connect with default DB creds
-
ExecutionExecute arbitrary Python or COPY PROGRAM OS command
-
ImpactFull 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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 3Improper neutralization of directives in dynamically evaluated code within letta-ai letta 0.16.4 allows remote attackers
Server-side request forgery in letta-ai letta 0.16.4 allows authenticated remote attackers to manipulate ImageContent pa
EUVD-2026-104692
GHSA-g524-hhf9-5x95
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB