Together.ai disclosed in its official post, “Security Event: Prompt Leakage for Requests in June and July of 2026,” that prompt leakage affected some submitted requests in June and July 2026.
The problem extends beyond a single exposed prompt. A model’s context often includes user profiles, retrieved passages, tool arguments, and business data alongside the prompt. For enterprises, prompts have become operational data rather than merely chat text.
The public summary does not specify the number of affected requests, the duration of the incident, the attack path, or the technical root cause. It is therefore not possible to attribute the incident directly to a tenant-isolation configuration, or to fill in an investigation conclusion on Together.ai’s behalf.
However, the incident exposes an issue that needs to be addressed: once an Agent connects to a third-party model, developers are managing an entire data pipeline, not just making an API call.
More Than a Prompt Was Exposed
Start by breaking down the data contained in a prompt.
A typical customer-service Agent may send the model a request containing:
- User names, order numbers, and conversation history
- Contract passages, database records, or internal knowledge-base content retrieved through RAG
- Function Calling tool names and arguments
- System prompts, rules, examples, and business context
- Intermediate results generated by the Agent during earlier steps
Here is a simplified structured example:
messages = [
{
"role": "system",
"content": "你是订单客服。不得透露用户隐私信息。"
},
{
"role": "user",
"content": "请查询订单 ORD-2048 的物流,并判断是否需要退款。"
},
{
"role": "tool",
"content": "{\"customer_email\": \"lin@example.com\", \"address\": \"上海市浦东新区某地址\"}"
}
]
This example is short. A production Agent’s prompt may be much longer, and sensitive fields may be buried in tool return values, retrieved documents, and historical state.
Together.ai said the exposed material consisted of request content submitted by users to the platform. In other words, anything that entered a prompt could have been copied into an incorrect log, error sample, debugging trace, or another storage location where it should not have appeared.
For an ordinary application, this may amount to a logging misconfiguration. For an Agent, the impact can spread through the workflow. A contaminated request may expose not only the current conversation but also context accumulated through previous tool calls.
Enterprise deployments face added complications. Logs often also retain request_id, account information, tenant identifiers, timestamps, and model parameters. Combined, these fields may be enough to reconnect an otherwise isolated prompt to a particular customer and business process.
Agents Carry More Risk Than Chat Applications
A single-turn chat application follows a relatively short data path:
用户 → 应用 → 模型 → 响应
An Agent typically adds an execution chain:
用户 → Agent → 检索 / 代码执行 / 外部 API → 再次调用模型 → 执行动作
Every subsequent model call may reassemble data returned by earlier tools into the prompt.
Consider a code-repair Agent that reads repository files, retrieves dependency documentation, runs tests through a shell, and then sends error logs back to the model. Its prompt may include file contents, environment variables, test data, fragments of access tokens, and internal paths.
More importantly, Agents take actions. When a chat model produces incorrect text, the damage is usually limited to the content itself. When an Agent misuses a tool, it may send email, modify a database, submit code, or invoke a billing API.
Assessing this leak therefore requires more than identifying which text was exposed. Three additional questions matter:
- Could the exposed content identify a person or customer?
- Could it be linked to other requests through
request_id? - Does it include credentials, arguments, or state that can drive executable tools?
If any answer is “yes,” the incident is about Agent permissions and data boundaries, not ordinary logging.
A Third-Party Model Chain Needs More Than a Disclaimer
A single third-party model call may pass through multiple parties:
你的应用 → Together.ai → 上游推理基础设施
The application decides what to send. The model host operates and isolates requests. The upstream infrastructure performs the computation. Each layer holds only part of the picture, and each bears part of the responsibility.
The goal is not to identify one sole responsible party. Enterprises need verifiable controls rather than relying entirely on contractual disclaimers.
Governance can be divided into four areas.
First, data minimization. Do not place every historical message in the prompt. Send only the fields required for the current task. Crop retrieval results by field, and project tool return values before use:
def project_tool_result(result: dict) -> dict:
allowed = {"status", "tracking_number", "estimated_delivery_date"}
return {key: value for key, value in result.items() if key in allowed}
Second, redaction. Email addresses, phone numbers, physical addresses, identification numbers, and customer IDs should not enter a third-party model unchanged. Replace them with temporary identifiers whenever possible.
Third, request-level isolation. Generate distinct identifiers for tenants, users, and tasks, and ensure they carry through model routing, logs, caches, and traces. Do not rely on the user field in the request body, because it is only a caller-supplied label.
Fourth, least-privilege tools. An Agent calling an external API should not receive long-lived credentials. Short-lived tokens, scoped access, and approval workflows remain necessary.
When procuring a third-party model service, organizations should ask directly: Do prompts enter traces? How long are error samples retained? Who can access them? Are customer-defined retention periods supported? Can the provider supply tenant-isolated audit records?
These questions are more relevant to production costs than benchmarks in a README.
Log Retention Is One of the Largest Exposure Surfaces
Many teams add traces to applications to diagnose failures. After an Agent runs through multiple steps, it is difficult to determine why a tool was called without a trace.
The problem is that observability systems often retain full content by default:
messagesorpromptcompletiontool_callstool_resultinputsandoutputs- Request fragments embedded in exception stack traces
- Evaluation datasets prepared for human annotation
Before production, each of the following fields should be reviewed:
| Check | Questions to confirm |
|---|---|
| Content | Are the full prompt, completion, and tool returns stored? |
| Identifiers | Do they include user IDs, email addresses, order numbers, or internal paths? |
| Credentials | Are Authorization headers, API keys, cookies, or tokens recorded? |
| Tenants | Is there a separate tenant_id, and can it prevent cross-tenant queries? |
| Permissions | Do development, operations, SaaS, and support teams share the same access group? |
| Retention | Are there defined TTLs, deletion procedures, and backup policies? |
| Exports | Are error samples redacted before entering an evaluation pipeline? |
| Alerts | Could sensitive fields be written to logs unintentionally? |
Observability does not require unlimited retention. Teams can record metadata first, then sample content temporarily when needed:
trace_event = {
"request_id": request_id,
"tenant_id": tenant_id,
"agent_step": step,
"tool_name": tool_name,
"duration_ms": duration_ms,
"status": status,
}
If troubleshooting genuinely requires the prompt, apply field-level redaction at collection time. In highly sensitive industries, teams can retain hashes, lengths, model versions, and error codes without retaining the original text.
The export path also needs review. An internal logging system may be well protected, but once data is sent to an incorrect platform, Sentry, Slack, or a third-party evaluation tool, the original text has crossed its established permission boundary.
The Together.ai Incident Still Has Several Key Questions Unanswered
Together.ai’s official post is titled “Security Event: Prompt Leakage for Requests in June and July of 2026.” Its public summary confirms the incident window: June and July 2026. It also confirms that prompt leakage affected some user-submitted requests.
According to the original material, the incident reached the Hacker News front page. The page showed 21 points and eight comments at the time. Discussion quickly focused on two questions: How many requests were affected, and where was the leaked content stored and who could access it?
The available public summary still does not answer:
- The exact number of affected requests
- When the leakage began and ended
- The complete attack path
- The specific technical root cause
- Which logs, traces, or internal systems were involved
- Whether cross-tenant access occurred
- What notifications, remediation, and audit scope customers received
The last two points are especially important. There is not enough evidence to claim that this was a cross-tenant isolation failure, nor can configuration errors, code defects, or exposure through a logging system be ruled out.
Original sources:
- Together.ai: Security Event: Prompt Leakage for Requests in June and July of 2026
- Hacker News: Discussion thread
What This Incident Changes for Enterprise Agents
The importance of this incident does not hinge on whether Together.ai temporarily loses customers. Enterprise Agents have turned prompts into business data, and model inputs may contain personal information, retrieved documents, tool arguments, and execution state. Protecting databases and API keys alone is no longer enough.
Request-level isolation, field-level redaction, and verifiable log-retention policies are likely to become important criteria when enterprises procure model services. The reason is straightforward: model providers can be replaced, but once customer data enters the wrong path, retracting a response cannot erase its history.
This also differs from the API-key leaks that have become common in the past. A leaked key can usually be revoked, while business context embedded in a prompt may not be reconstructible or replaceable. The full impact depends on the completed investigation. Until then, organizations should inventory the fields entering their models, the people with access to their logs, and the boundaries of tenant isolation rather than speculate about the root cause.