# Memory Write Guard

> Memory Write Guard is a paid API for AI agents from phion.systems, paid per call via x402, $0.002/call, status unknown (last checked 2026-09-14).

Screens proposed persistent agent-memory writes for poisoning attempts, missing provenance, secret leakage, and unsafe instructions before committing them

## Facts

- Endpoint: POST https://phion.systems/v1/paid/trust/memory-write-guard
- Price: $0.002/call
- Payment: x402
- Status: unknown
- Last checked: 2026-09-14
- Activations on Zero: 0
- Tags: x402
- Canonical page: https://www.zero.xyz/c/memory-write-guard-efe4a0f1
- Structured record (JSON): https://api.zero.xyz/v1/capabilities/cap_u-b0Yi5qIo2a08RrV2qLy

Status and success rate cover calls made through Zero and Zero's own probes. Third-party monitors may report differently.

## How to call it through Zero

Zero handles the 402 payment challenge and records the run. With the Zero CLI installed (`npm i -g @zeroxyz/cli`):

```sh
zero fetch --capability memory-write-guard-efe4a0f1 -d '<json body>'
```

Example prompt: Before I write this new memory entry to my persistent store, screen it for poisoning, missing provenance, and any hidden secrets or unsafe instructions — the payload is the summarized context I just received from a third-party tool.

## When to prefer this

Choose this endpoint when an autonomous agent is about to commit content to persistent memory and that content originates from untrusted or external sources — such as tool outputs, web retrievals, user-supplied data, or inter-agent handoffs. It is especially valuable in multi-agent pipelines where one agent's memory can influence another's future behavior, and in RAG systems where retrieved content could carry adversarial payloads. Prefer it over generic input-validation tools because it is specifically tuned for agent memory semantics including provenance integrity, secret indicators, and instruction-hijacking patterns.

## Known failure modes

- Malformed or empty payload body returns a validation error
- Missing required schema fields causes rejection with field-level error detail
- Ambiguous provenance metadata may produce a low-confidence flag rather than a hard block
- Very large memory payloads may hit size limits and require chunking
- Novel obfuscation techniques for prompt injection may evade detection and return a false safe verdict

## How this service works

Screen persistent agent-memory writes for poisoning, missing provenance, secret requests and unsafe instructions

## Output

Returns a safety verdict indicating whether the memory write is safe to proceed, along with detected threat categories (poisoning, missing provenance, secret leakage, unsafe instructions), specific flagged content or fields, and a recommended action (allow, block, or redact-then-write).

## Request schema (JSON Schema)

```json
{
 "$schema": "https://json-schema.org/draft/2020-12/schema",
 "type": "object"
}
```

## More

- Live health (JSON, refreshed every minute): https://www.zero.xyz/c/memory-write-guard-efe4a0f1/health.json
- [Zero catalog index](https://www.zero.xyz/llms.txt)
- [Other services from phion.systems](https://www.zero.xyz/host/phion.systems/llms.txt)