코딩 에이전트가 프로젝트 컨텍스트를 회상하고 실행 전 가드 체크를 수행할 수 있도록 로컬 우선 방식의 생물학적 메모리 루프를 제공합니다.
다른 이름 Evilander/Audrey
- 스타
- 26
- Tools
- 23
- 다운로드, 30일
- —
- 최신 버전
- 2.1.1
- 마지막 커밋
- 2026년 10월 29일
- 라이선스
- MIT
Audrey MCP란?
코딩 에이전트가 프로젝트 컨텍스트를 회상하고 실행 전 가드 체크를 수행할 수 있도록 로컬 우선 방식의 생물학적 메모리 루프를 제공합니다. 23개 도구를 제공합니다. 예: memory_encode, memory_recall, memory_consolidate.
프로젝트 README에서 생성된 요약
Audrey MCP server 정보
Audrey는 Claude Code 및 Codex와 같은 코딩 에이전트를 위해 설계된 로컬 우선 방식의 생물학적 메모리 루프를 제공합니다. 세션 시작 시 에이전트 범위의 메모리 브리핑을 주입하고, 도구 호출을 모니터링하여 반복적인 실수를 방지하는 방식으로 작동합니다. 도구의 결과와 이전 체크 사항을 연결함으로써 프로젝트 내에서 무엇이 성공하고 실패했는지에 대한 지속적인 기록을 생성합니다.
사용자는 autopilot 명령을 사용하여 지원되는 CLI를 자동으로 구성하고 서비스를 설정할 수 있습니다. 시스템은 SQLite 백엔드를 사용하여 에피소드, 시맨틱 메모리 및 절차적 규칙을 저장합니다. 또한 기억된 파일 경로 나 패키지 스크립트가 현재 저장소에 여전히 존재하는지 확인하는 그라운딩 기능을 포함합니다. 이를 통해 에이전트가 삭제된 파일에 기반한 오래된 명령을 수행하지 않도록 보장합니다.
개발자는 Node.js 22.16+ 또는 24+가 필요한 로컬 설치를 통해 시스템과 상호작용합니다. 대부분의 프로세스는 자동으로 실행되지만, 사용자가 수동으로 그라운딩을 트리거하거나 가드 결정을 검사할 수 있습니다. 시스템은 기본적으로 fail open 방식으로 설계되었으나, 특정 보안 요구 사항에 따라 사용자가 fail-closed 설정을 활성화할 수 있습니다.
활용 사례
- 1반복적인 배포 실패 방지최근 실패 지문(fingerprint)을 대조하여 AI 에이전트가 잘못된 배포 명령을 실행하는 것을 방지할 수 있습니다.
- 2저장소 변경 사항에 따른 메모리 검증리팩토링 후 저장된 프로젝트 지침이 여전히 유효한 파일이나 스크립트를 참조하고 있는지 개발자가 확인할 수 있습니다.
- 3명시적인 사용자 선호도 캡처자연어를 통해 AI에게 특정 프로젝트 규칙이나 개인적인 코딩 선호도를 기억하도록 지시할 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
Audrey MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 Audrey MCP 설치
$ claude mcp add audrey -- npx -y audreyCursor에 Audrey MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"audrey": {
"command": "npx",
"args": [
"-y",
"audrey"
]
}
}
}VS Code에 Audrey MCP 설치
.vscode/mcp.json
{
"servers": {
"audrey": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"audrey"
]
}
}
}VS Code CLI에 Audrey MCP 설치
$ code --add-mcp '{"name":"audrey","type":"stdio","command":"npx","args":["-y","audrey"]}'Claude Desktop에 Audrey MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"audrey": {
"command": "npx",
"args": [
"-y",
"audrey"
]
}
}
}Codex에 Audrey MCP 설치
$ codex mcp add audrey -- npx -y audreyCodex config.toml에 Audrey MCP 설치
~/.codex/config.toml
[mcp_servers.audrey] command = "npx" args = ["-y", "audrey"]
Gemini CLI에 Audrey MCP 설치
$ gemini mcp add -s user audrey npx -- -y audreyGemini settings.json에 Audrey MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"audrey": {
"command": "npx",
"args": [
"-y",
"audrey"
]
}
}
}HostedMCP가 2026년 11월 16일에 실행 확인
audrey 2.1.1을(를) 네트워크와 키가 없는 격리된 컨테이너에서 이 명령으로 실행했습니다. 응답하며 도구 23개를 보여 주었습니다.
Audrey MCP 도구 23
tools/list로 서버에서 직접 읽음memory_encodememory_recallmemory_consolidatememory_introspectmemory_groundmemory_resolve_truthmemory_exportmemory_importmemory_forgetmemory_validatememory_decaymemory_status
| memory_encode | — | |
| memory_recall | — | |
| memory_consolidate | — | |
| memory_introspect | — | |
| memory_ground | — | |
| memory_resolve_truth | — | |
| memory_export | — | |
| memory_import | — | |
| memory_forget | — | |
| memory_validate | — | |
| memory_decay | — | |
| memory_status | — |
도구 23개 모두 보기도구 수 줄이기
memory_reflectmemory_dreammemory_greetingmemory_observe_toolmemory_recent_failuresmemory_capsulememory_preflightmemory_guard_beforememory_guard_aftermemory_reflexesmemory_promote
| memory_reflect | — | |
| memory_dream | — | |
| memory_greeting | — | |
| memory_observe_tool | — | |
| memory_recent_failures | — | |
| memory_capsule | — | |
| memory_preflight | — | |
| memory_guard_before | — | |
| memory_guard_after | — | |
| memory_reflexes | — | |
| memory_promote | — |
구성
AUDREY_AGENTLogical memory owner used for scoped operations (defaults to local-agent)
AUDREY_DATA_DIRDirectory for the SQLite memory store (defaults to ~/.audrey/data)
AUDREY_EMBEDDING_PROVIDERlocal (default, on-device model), openai, gemini, or mock
AUDREY_ENABLE_ADMIN_TOOLSSet to 1 to expose the export, import, forget, and promote tools
AUDREY_LLM_PROVIDEROptional reflection/consolidation model: anthropic, openai, chatgpt, or mock; unset keeps everything local
| 이름 | 설명 | 유형 |
|---|---|---|
| AUDREY_AGENT | Logical memory owner used for scoped operations (defaults to local-agent) | |
| AUDREY_DATA_DIR | Directory for the SQLite memory store (defaults to ~/.audrey/data) | |
| AUDREY_EMBEDDING_PROVIDER | local (default, on-device model), openai, gemini, or mock | |
| AUDREY_ENABLE_ADMIN_TOOLS | Set to 1 to expose the export, import, forget, and promote tools | |
| AUDREY_LLM_PROVIDER | Optional reflection/consolidation model: anthropic, openai, chatgpt, or mock; unset keeps everything local |
자동 검사
2026년 11월 12일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능통과
- 오픈 소스 라이선스 (OSI)통과
- 최근 1년 내 커밋 또는 릴리스통과
- 패키지 이름이 인기 패키지와 유사하지 않음통과
- 원격 엔드포인트가 HTTPS 사용검사되지 않음
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 모델에 대한 숨겨진 지침 없음통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음통과
README
GitHub에서 보기Memory before action
You fix the deploy command on Monday. On Thursday, a fresh session tries the broken version again.
Audrey brings relevant project memory into the next session, checks supported tool calls before they run, and links their reported outcomes to the check that preceded them. A Guard decision carries evidence IDs you can inspect. Grounding can flag memories that reference deleted files or package scripts.
Try the SQLite-backed demo before configuring a host:
npm exec --yes --package=audrey -- audrey demo --scenario repeated-failure
The demo simulates a failed deploy, passes read-only inspection commands through the hook, and checks a proposed retry. It does not execute a deployment or change host configuration. After npm fetches the package, the demo needs no API key, model download, or network call.
Meet Audrey Autopilot
Install Audrey once, review the hooks once, and then use Codex or Claude Code normally.
npm install -g audrey
audrey install --host auto
Requires Node.js 22.16+ (22.x) or 24+. SQLite is built into Node, so fresh installs and npx launches work without approving dependency scripts. npm 11.17+ may warn about dependency scripts, and npm 12 may report that it blocked them; those scripts are not required for Audrey's CPU embedding runtime.
auto configures whichever supported CLIs are installed. You can choose one explicitly:
audrey install --host codex
audrey install --host claude-code
Restart the host after installation. Codex asks you to trust non-managed hooks once through /hooks; Claude Code may also ask you to approve project or plugin components. Audrey is automatic after that explicit install-and-trust step—never secretly installed.
Autopilot then closes the loop:
| Moment | What Audrey does |
|---|---|
| Session starts | Injects a compact, agent-scoped memory briefing |
| You send a prompt | Recalls relevant evidence; explicitly durable phrases such as “remember that…” or “I prefer…” can become memories |
| Bash/edit/write is proposed | Checks exact prior failures, trusted rules, procedures, contradictions, and memory health |
| The tool finishes | Correlates tool_use_id to the Guard receipt and records the redacted outcome |
| A tool failure is reported | Forms a durable, sanitized failure memory for the next attempt |
| The turn stops or context compacts | Runs lightweight, due-only consolidation without holding the conversation open |
An outcome reflects the tool's reported status. A zero exit code can still produce stale or incorrect output. Custom integrations can declare required result checks in beforeAction and supply the actual output to afterAction. Guard then records a mismatch as failed and an unverifiable reported success as unknown. Audrey does not generate application-specific checks or infer the expected values.
Each hook event carries a host-declared timeout (30 seconds for the PreToolUse Guard check). Audrey caps individual hosted embedding/LLM requests below that deadline; this is not a deadline for the entire hook, and local model initialization has no equivalent internal timeout. Errors caught by Audrey fail open by default: the hook emits no decision. Set AUDREY_HOOK_FAIL_CLOSED=1 to deny a PreToolUse action on a caught error. If the host terminates the process first, the host determines what happens. Other lifecycle hooks have no deny path and always degrade open on caught errors.
A small story about a failed deploy
The first attempt fails:
$ npm run deploy
Error: deployment target is missing
Audrey keeps a redacted trace and an action fingerprint. If another session under the same agent identity proposes that action, Guard can deny the retry with evidence. A later recorded success for that fingerprint clears the exact-failure block. If the failed action declared result checks, recovery must pass the same checks. The default exact-failure window is seven days; other memory warnings are evaluated separately.
Fixing a file or deployment target does not itself clear the block. For a deliberate retry, the Guard API accepts acknowledgePriorFailure: true (MCP/REST: acknowledge_prior_failure; CLI: --acknowledge-prior-failure). Autopilot also recognizes retry language in the current user prompt. Acknowledgement lowers the exact-failure block to a warning and preserves its evidence; it does not bypass separate policy warnings.
Guard does not yet evaluate whether a natural-language prerequisite has been satisfied. A trusted must-follow memory can keep blocking even after its suggested repair succeeds. Review the cited rule when that happens; changing a command's spelling is not proof that its underlying problem is fixed.
Looking is not doing
Inspection commands such as grep, git status, and cat normally need no memory check. A non-zero exit from grep can simply mean there was no match.
A command whose every part is positively recognised as read-only skips Guard. The classifier rejects command substitution, redirects other than /dev/null, sudo, xargs, and environment assignments that could change command resolution. Inspection outcomes can be recorded, but are excluded from failure learning. Unrecognised commands remain guarded.
$ grep -rn "prisma" src/ Guard: silent
$ git status --short Guard: silent
$ cat prisma/schema.prisma Guard: silent
$ npm run deploy
Audrey Guard: BLOCKED
- recent_failure (high): This exact Bash action failed before: Prisma client was not generated. Run npm run db:generate before deploy.
- must_follow (high): Before running npm run deploy, run npm run db:generate because Prisma client must be generated first.
This excerpt illustrates the output of audrey demo --scenario repeated-failure.
When Guard does speak, it names the memory it is speaking from, and a remembered failure is matched to the proposed command by what it runs (npm run deploy against npm run deploy), not by how similar two strings look to an embedding.
Commands with execution-capable options or lifecycle scripts are guarded, including git ls-remote --upload-pack=..., npm pack --dry-run, and ss -K. The classifier is a convenience for ordinary inspection commands, not an operating-system sandbox. Repository configuration, shell expansion, and programs invoked by a reader can change what a command does. Use host permissions or a sandbox when enforcement is required.
What Audrey remembers
Audrey treats memory as more than a pile of text chunks.
- Episodes are things that happened: a user decision, a tool result, a project fact, a preference.
- Semantic memories are principles supported by accumulated evidence.
- Procedural memories are ways of acting: how to retry, verify, avoid, or recover.
- Contradictions stay visible instead of being silently overwritten.
- Confidence changes with source quality, evidence, age, retrieval, interference, context, and feedback.
- Low-value memories decay; repeated evidence can consolidate into longer-lived knowledge.
Every context packet includes memory IDs, confidence, provenance where available, and a reason for inclusion. Uncertain or disputed memories are labeled as such. Retrieved content is wrapped with a simple rule: memory is evidence, not authority; current system and user instructions always win.
Checking memories against the repository
Age is not the only way a memory goes wrong. A note saying "ship with npm run deploy:prod" is perfectly recent, well sourced, and completely wrong the day that script is deleted. Worse, every recall reinforces it, because retrieval counts as evidence that a memory is useful. A confidently stated, well-supported, false instruction is more damaging than no memory at all.
Audrey checks a narrow, useful part of this problem: whether referenced repository paths and package script names still exist. When a memory is written with project context, it records only anchors that resolve at that moment. A missing anchor can then distinguish a later repository change from a reference that never resolved.
Existence does not establish correctness. A script can keep its name while changing behavior, and an intact file can contain obsolete instructions. Grounding does not execute scripts, prove a fix, or verify arbitrary claims in prose.
audrey ground
[audrey] Grounding memories against /home/you/project
[audrey] Checked 14: 12 still true, 2 broken, 0 repaired.
[audrey] 01K8ZQ... references a missing npm_script: deploy:prod
[audrey] 01K8ZR... references a missing path: scripts/release.mjs
Broken memories are not deleted. They keep their content, say plainly what they still refer to, and take a confidence penalty so they stop leading by default while remaining readable and repairable. They also stop being eligible for the packet's must-follow section — that is the section that can force a Guard block, and a rule naming a file that no longer exists is a rule nobody can follow.
Repair is symmetric. Restore the file or the script and the next check clears the flag. A checkout that has moved reports unknown rather than broken, because a memory should not be discredited for describing a project this machine cannot currently see.
Memories with no checkable claims are left unlabeled. Silence is not a clean bill of health, and presenting it as one would be the same mistake pointed the other way.
Daily use
Most of this runs on its own once Autopilot is installed. You do not invoke recall, and you do not invoke Guard. The table is here for the parts you would reach for deliberately, and so the automatic parts are legible rather than magic.
| What | When you want it | Why it helps | How |
|---|---|---|---|
| Autopilot | Always, after one install | The whole point. Memory arrives before the agent acts instead of after you notice it went wrong. | audrey install --host auto, restart the host, approve hooks once |
| Guard | Automatic, before supported edit, write, or shell tool calls | Checks action fingerprints against recorded failures and surfaces memory warnings. Recognised read-only commands skip the check. Repairing the repository alone does not clear a prior failure. | Runs at PreToolUse. Manually: audrey guard --tool Bash --strict |
| Grounding | After deleting or renaming things a memory might mention | Flags previously observed paths or package script names that no longer exist. | audrey ground, or let the maintenance sweep do it |
| Session briefing | Automatic at session start | Small, scoped packet instead of pasting context every time. Unchanged memories inject once per session; changes to content or standing are sent again. | SessionStart hook. Preview with audrey greeting |
| Explicit capture | When you say "remember that…" or "I prefer…" | Deliberate memories are worth more than inferred ones, and phrasing it that way is enough. | Just type it. Autopilot picks up those sentence shapes |
| Consolidation | Automatic when idle; manually before a long break | Repeated episodes become one principle. Otherwise the store is a pile of near-duplicates and recall gets noisy. | audrey dream |
| Contradictions | When two memories disagree | Neither one silently wins. Both stay visible and labeled until something resolves them. | Surfaced in packets; memory_resolve_truth to settle one |
| Decay | Confidence ages during recall; run maintenance to mark dormant memories | Age lowers confidence. Explicit decay can move weak memories out of active retrieval. Autopilot consolidation does not run this dormancy pass. | audrey dream or memory_decay |
| Promote | When a pattern deserves to be a repo rule | Moves a learned habit out of memory and into a file your team can read and review. | audrey promote --dry-run first |
| Impact | When reviewing memory feedback | Reports explicit used/helpful/wrong feedback and frequently validated memories. It does not measure time saved or independently establish that a blocked action would have failed. | audrey impact --window 30 |
| Snapshot | Backups, or moving to a new machine | Full store in one JSON file. Import treats it as untrusted: redacted and stripped of trust markers on the way in. | AUDREY_ENABLE_ADMIN_TOOLS=1, then memory_export / memory_import |
| Doctor | Packets stopped arriving | The two real causes are a drifted hook entrypoint and starved consolidation. Doctor names which one. | audrey doctor |
| Demo | Before configuring a host | Exercises a simulated failure and blocked retry in temporary SQLite storage, with no API key or network call. | audrey demo --scenario repeated-failure |
| REST sidecar | Custom agents that are not Codex or Claude Code | Same memory runtime, same evidence contract, over HTTP. Python and JS clients included. | audrey serve with AUDREY_API_KEY set |
What Audrey deliberately does not do
Audrey does not upload your memory to a hosted service by default. It does not treat every sentence as permanent truth. It does not promote instructions from arbitrary tool output into trusted policy. It does not claim that a small local benchmark proves state-of-the-art memory quality.
Raw prompt events and tool bodies are not retained by default. Audrey stores hashes, bounded summaries, fingerprints, and redaction metadata. Explicit user-memory language is persisted intentionally; tool failure memories are sanitized first. Admin export/import/forget/promote surfaces are disabled unless AUDREY_ENABLE_ADMIN_TOOLS=1.
At-rest encryption, identity-bound tenant authorization, rate limiting, and regulated retention remain deployment responsibilities today. They are not hidden behind a “production ready” badge.
Why a team might actually want this
Fewer repeated mistakes
Guard checks memory at the point where it can change an action, not after the damage is done. Exact failure fingerprints avoid the noisy “one Bash command failed, so all Bash commands are suspicious” behavior.
Continuity across agent sessions
Codex and Claude Code use the same memory runtime and evidence contract. Generated configurations use separate codex and claude-code agent identities, so they do not automatically recall each other's memories. Cross-agent Autopilot recall requires the explicit AUDREY_AUTOPILOT_SCOPE=shared setting in the host runtime environment; this broadens recall across the store. MCP, REST, JavaScript, and Python clients make the core usable in custom agents too.
Evidence a human can inspect
Allow, warn, and block decisions carry receipts and evidence IDs. Outcome records connect back to those receipts. Teams can ask not only “what did the agent remember?” but “which memory changed this action, and was that useful?”
Local control
The default store is SQLite, FTS5, and sqlite-vec. Local embeddings are the default. Cloud embedding or LLM providers require explicit configuration.
A safer shared store
Agent-scoped recall continues through validation, contradiction detection, interference, affect, failure lookup, capsules, greetings, Guard, and REST request routing. Recall updates retrieval count and last-reinforced timestamp for returned semantic and procedural memories. Capsule and Guard filtering may further narrow those results. Explicit validation feedback (memory_validate / /v1/validate) separately updates usage and salience from a caller's used/helpful/wrong assessment.
Vector candidates are partitioned by agent before nearest-neighbor ranking, so one busy agent cannot crowd another out of a bounded search. For hard tenant boundaries, still use a distinct AUDREY_DATA_DIR per tenant or security domain.
Technical reference
Everything below is the machinery. The short version above is the product.
Requirements and packages
- Node.js 22.16+ (22.x) or 24+; Node 20 and 23 are no longer supported
- npm package:
audrey - Python client:
audrey-memory - Default storage: local SQLite + FTS5 +
sqlite-vec - Default embeddings: local 384-dimensional model
npm install audrey
pip install audrey-memory
Audrey uses node:sqlite; sqlite-vec ships its extension in platform packages. The local embedding runtime also includes its CPU binaries, so npm install --ignore-scripts audrey works. Keep optional dependencies enabled: they contain the platform files for sqlite-vec and sharp. GPU acceleration may require additional ONNX Runtime libraries for your platform. Some supported Node releases print an experimental SQLite warning at startup; it does not prevent operation.
For Autopilot, prefer a global or otherwise stable installation. Hook and MCP configuration pins the actual Node executable and Audrey entrypoint; an ephemeral npx cache is not a durable production runtime.
Host configuration
Preview or apply lifecycle hooks independently:
audrey hook-config claude-code
audrey hook-config claude-code --apply --scope local
audrey hook-config claude-code --apply --scope project
audrey hook-config claude-code --apply --scope user
audrey hook-config codex
audrey hook-config codex --apply --scope project
audrey hook-config codex --apply --scope user
Claude Code scope mapping follows the host’s terminology:
local→.claude/settings.local.jsonproject→.claude/settings.jsonuser→~/.claude/settings.json
Codex supports project .codex/hooks.json and user ~/.codex/hooks.json; it has no local hook scope. Audrey preserves unrelated hooks, replaces older Audrey-owned handlers, writes a private timestamped backup, and is idempotent on repeat installation. Project-adjacent backup names match *.audrey-*.bak; keep that pattern ignored because a host config can contain unrelated credentials.
Audrey respects CLAUDE_CONFIG_DIR and CODEX_HOME. Generated hooks pin the stable Node executable, Audrey entrypoint, data directory, agent identity, and non-secret provider choices used at install time. With local embeddings, an Autopilot install warms the model cache; set AUDREY_DISABLE_WARMUP=1 to skip it. Each hook still runs in a new process and initializes an embedding pipeline when needed, so cached model files do not eliminate startup latency.
Generate MCP configuration without applying it:
audrey mcp-config codex
audrey mcp-config generic
audrey mcp-config vscode
Remove Audrey-owned MCP registrations and hooks with the same host and scope you installed:
audrey uninstall --host auto --scope user
audrey uninstall --host claude-code --scope local
audrey uninstall --host codex --scope project
Add --dry-run to preview uninstall without changing either host. Add --mcp-only only when you intentionally want to preserve Audrey hooks.
Autopilot safety contract
The shared hook adapter normalizes current Codex and Claude Code payloads.
- Context injection is bounded by
AUDREY_CONTEXT_BUDGET_CHARS(default 4000; Autopilot uses a conservative 3200-character packet unless overridden). - Prompt and tool retrieval queries are bounded before embedding. Large edits carry hashes and lengths instead of file bodies; exact Guard identity uses a full redacted digest rather than a truncated prefix.
- The generated default hooks guard and observe
Bash,Edit,MultiEdit,Write,NotebookEdit,apply_patch, and everymcp__*tool from connected MCP servers, excluding Audrey's own memory tools so the Guard never guards itself. - A Bash command is only guarded when it can have side effects. A command whose every part is positively recognised as read-only (
grep,ls,sed -n,git status,npm ls, and similar; no command substitution, no redirect except to/dev/null, nosudo,xargs, oreval) skips the preflight, and a non-zero exit from it is recorded but never treated as a failure to avoid. Anything the classifier does not recognise is guarded. - A remembered Bash failure is matched to a proposed command by the verbs it runs (
npm run deploy,git push), not by how similar the two command strings read. - Pre/post correlation uses
session_id + tool_use_id, so parallel tool calls do not attach to the wrong receipt. - Claude
PostToolUseFailureand Codex responses that explicitly expose a non-zero exit normalize to the same failure path. Current Codex hooks can omit Bash exit status; Audrey records an opaque result asunknown, never as invented success. - On an internal error, every hook logs to stderr and emits
{}(no opinion, so the tool proceeds). OnlyPreToolUsechanges behavior underAUDREY_HOOK_FAIL_CLOSED=1, emitting a deny decision instead; context-injection and post-tool hooks have no deny path and always emit{}. - Stop hooks always emit valid JSON and never continue or block a completed turn.
Codex hook interception is a guardrail, not a complete shell-policy boundary. The current host contract does not intercept every richer unified_exec path and may omit the exit status of silent Bash failures. See the Codex hooks documentation. Use the Guard receipt as evidence, and keep sandboxing, approvals, CI, and deployment controls in place.
JavaScript API
import { Audrey } from 'audrey';
const memory = new Audrey({
dataDir: './audrey-data',
agent: 'payments-agent',
embedding: { provider: 'local', dimensions: 384 },
});
await memory.encode({
content: 'Stripe returns HTTP 429 above 100 requests per second.',
source: 'direct-observation',
tags: ['stripe', 'rate-limit'],
context: { service: 'billing' },
});
const capsule = await memory.capsule('increase Stripe throughput', {
scope: 'agent',
budgetChars: 3000,
});
const before = await memory.beforeAction('npm run deploy:billing', {
tool: 'Bash',
cwd: process.cwd(),
strict: true,
});
console.log(before.decision, before.evidence_ids, before.receipt_id);
// Only execute an authorized action when before.ok_to_proceed is true.
// After execution, close this receipt with memory.afterAction({
// receiptId: before.receipt_id, outcome: 'succeeded' | 'failed' | 'unknown',
// errorSummary: '...' // when available
// });
// Report the observed outcome; creating a receipt does not execute the action.
await memory.closeAsync();
Audrey MCP 질문
Audrey MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add audrey -- npx -y audrey를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
Audrey MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
Audrey MCP는 어떤 도구를 제공하나요?
23개 도구를 제공합니다. 예: memory_encode, memory_recall, memory_consolidate, memory_introspect, memory_ground.
Audrey를 사용하려면 API 키나 네트워크 연결이 필요한가요?
데모 모드는 내장된 SQLite 백엔드를 사용하므로 API 키, 모델 다운로드 또는 네트워크 호출이 필요하지 않습니다.
Audrey가 훅 실행 중 오류를 발생시키면 어떻게 되나요?
기본적으로 Audrey는 fail open 방식으로 동작하며, 이는 훅이 아무런 결정도 내리지 않음을 의미합니다. AUDREY_HOOK_FAIL_CLOSED 환경 변수를 설정하여 이 동작을 변경할 수 있습니다.