Metadata-Version: 2.4
Name: ferryte
Version: 0.2.1
Summary: Verification for agent forgetting: prove your AI agent stops acting on revoked, stale, poisoned, or cross-tenant data.
Project-URL: Homepage, https://ferryte.dev
Project-URL: Documentation, https://github.com/getferryte/ferryte#readme
Project-URL: Repository, https://github.com/getferryte/ferryte
Project-URL: Issues, https://github.com/getferryte/ferryte/issues
Project-URL: Changelog, https://github.com/getferryte/ferryte/blob/main/CHANGELOG.md
Author: Ferryte contributors
License: Business Source License 1.1
        
        Parameters
        
        Licensor:             Ferryte (and its commercial entity)
        Licensed Work:        Ferryte v0.2.0 or later. The Licensed Work is
                              (c) 2026 Ferryte contributors.
        Additional Use Grant: You may make production use of the Licensed Work,
                              provided that you do not offer the Licensed Work to
                              third parties on a hosted or embedded basis that
                              competes with a Ferryte commercial offering. A
                              "competing offering" is a product or service marketed
                              to third parties that provides verification, auditing,
                              or attestation of AI agent memory forgetting as a
                              managed or hosted service.
        Change Date:          Three years from the date each version is first
                              published.
        Change License:       Apache License, Version 2.0
        
        -----------------------------------------------------------------------------
        
        Terms
        
        The Licensor hereby grants you the right to copy, modify, create derivative
        works, redistribute, and make non-production use of the Licensed Work. The
        Licensor may make an Additional Use Grant, above, permitting limited
        production use.
        
        Effective on the Change Date, or the fourth anniversary of the first publicly
        available distribution of a specific version of the Licensed Work under this
        License, whichever comes first, the Licensor hereby grants you rights under
        the terms of the Change License, and the rights granted in the paragraph
        above terminate.
        
        If your use of the Licensed Work does not comply with the requirements
        currently in effect as described in this License, you must purchase a
        commercial license from the Licensor, its affiliated entities, or authorized
        resellers, or you must refrain from using the Licensed Work.
        
        All copies of the original and modified Licensed Work, and derivative works
        of the Licensed Work, are subject to this License. This License applies
        separately for each version of the Licensed Work and the Change Date may vary
        for each version of the Licensed Work released by Licensor.
        
        You must conspicuously display this License on each original or modified copy
        of the Licensed Work. If you receive the Licensed Work in original or
        modified form from a third party, the terms and conditions set forth in this
        License apply to your use of that work.
        
        Any use of the Licensed Work in violation of this License will automatically
        terminate your rights under this License for the current and all other
        versions of the Licensed Work.
        
        This License does not grant you any right in any trademark or logo of
        Licensor or its affiliates (provided that you may use a trademark or logo of
        Licensor as expressly required by this License).
        
        TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
        AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
        EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
        TITLE.
        
        -----------------------------------------------------------------------------
        
        Covenants of Licensor
        
        In consideration of the right to use this License's text and the "Business
        Source License" name and trademark, Licensor covenants to MariaDB, and to all
        other recipients of the licensed work to be provided by Licensor:
        
        1. To specify as the Change License the GPL Version 2.0 or any later version,
           or a license that is compatible with GPL Version 2.0 or a later version,
           where "compatible" means that software provided under the Change License
           can be included in a program with software provided under GPL Version 2.0
           or a later version. Licensor may specify additional Change Licenses
           without limitation.
        
        2. To either: (a) specify an additional grant of rights to use that does not
           impose any additional restriction on the right granted in this License, as
           the Additional Use Grant; or (b) insert the text "None".
        
        3. To specify a Change Date.
        
        4. Not to modify this License in any other way.
        
        -----------------------------------------------------------------------------
        
        Notice
        
        The Business Source License (this document, or the "License") is not an Open
        Source license. However, the Licensed Work will eventually be made available
        under an Open Source License, as stated in this License.
        
        For more information on the use of the Business Source License for Ferryte,
        please see https://ferryte.dev/license.
        
        For more information on the use of the Business Source License generally,
        please see https://mariadb.com/bsl11/.
License-File: LICENSE
License-File: LICENSE-MIT.txt
Keywords: agents,ai,deletion,forgetting,lineage,memory,owasp,provenance,testing,verification
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: Other/Proprietary License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Security
Classifier: Topic :: Software Development :: Testing
Requires-Python: >=3.9
Requires-Dist: numpy>=1.26
Requires-Dist: pydantic>=2.6
Requires-Dist: rich>=13.7
Requires-Dist: typer>=0.12
Provides-Extra: api
Requires-Dist: fastapi>=0.110; extra == 'api'
Requires-Dist: uvicorn>=0.29; extra == 'api'
Provides-Extra: dev
Requires-Dist: mypy>=1.10; extra == 'dev'
Requires-Dist: pytest-cov>=5.0; extra == 'dev'
Requires-Dist: pytest>=8.0; extra == 'dev'
Requires-Dist: ruff>=0.4; extra == 'dev'
Provides-Extra: mem0
Requires-Dist: mem0ai>=0.1.0; extra == 'mem0'
Description-Content-Type: text/markdown

# Ferryte

**Verification for agent forgetting.**
**Source-available (BSL 1.1 → Apache 2.0) · commercial Cloud + Enterprise tiers.**

[Marketing site](https://ferryte.dev) · [Live dashboard demo](https://ferryte.dev/app) · [LICENSING](LICENSING.md) · [COMMERCIAL](COMMERCIAL.md)

> "Deleting an event doesn't remove the structured information derived out of it from the long term memory."
> — [AWS Bedrock AgentCore docs](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/short-term-delete-event.html)

When you delete a record, revoke a permission, or quarantine a source, your agent's *derived* memories (summaries, embeddings, extracted facts) often keep behaving as if the data is still there. The platform vendors document this. Almost nobody verifies it.

**Ferryte is the forgetting oracle.** It seeds canary memories, calls the real delete API, replays your agent, inspects both the store contents and the retrieval traces, and tells you exactly which derived artifacts still leak — including an honest map of what it cannot see.

It is built for one thing: catching the leak before your customer does.

## Why this exists

Agent memory is production state, but teams don't test it like production state. Sentry observes errors that already happened. Ferryte detects **counterfactual failures**: information that should no longer be allowed to influence behavior, but still does.

The crux:
- AWS Bedrock AgentCore: deleting a short-term event does not remove derived long-term memory records.
- Zep: deleting an episode does not regenerate the shared node summaries that already absorbed it.
- Mem0 / generic vector stores: deletes the row, but embeddings already in retrieval caches keep returning.

Ferryte is the layer that proves whether forgetting actually happened.

## What it does (v1)

1. **Seed** deterministic canary memories tagged by `source_id` and `tenant_id`.
2. **Revoke** via the backend's own delete / permissions API.
3. **Replay** agent probes AND directly inspect store contents + retrieval traces — not just final answers. (Final-answer-only verification gives false confidence.)
4. **Trace** the lineage from each source to every derived artifact it influenced; compute blast radius on revocation.
5. **Report** coverage + the blind-spot map (where we *cannot* prove forgetting — un-instrumented stores, laundered LLM-paraphrased derivations, external caches).
6. **Gate** CI: fail the build when a revoked marker re-enters retrieval or prompt.

Scenarios shipped:

- `source-revocation` — flagship: delete a source, prove no derivative still surfaces it.
- `cross-tenant-isolation` — Tenant A's data never reaches Tenant B's agent.
- `stale-fact` — agent refuses or flags facts past their valid window.
- `memory-poisoning` — planted malicious write is detected and quarantined.

## Install

```bash
pip install ferryte
```

## Quickstart (under 10 minutes)

```python
import ferryte
from mem0 import Memory

ferryte.instrument()              # one line; auto-patches detected memory clients
mem = Memory()                    # your existing code, unchanged
# ... your agent runs ...
```

Then in CI:

```bash
ferryte init                      # zero-config: discovers the agent + memory backend
ferryte test --scenario source-revocation
ferryte coverage                  # prints what was verified + the blind-spot map
```

A non-zero exit code on `ferryte test` means a revoked marker re-entered the agent's prompt. That's the build break.

## Architecture

```
your agent  ─┐
             │  one-line auto-patch
             ▼
      ferryte.instrument()
             │
   ┌─────────┼──────────────┐
   │         │              │
   ▼         ▼              ▼
backends    lineage      retrieval
adapters    graph         traces
   │         │              │
   └─────────┴──────┬───────┘
                    ▼
            forgetting oracle
                    │
        ┌───────────┼────────────┐
        ▼           ▼            ▼
    coverage    CI gate       dashboard
    + blind-    (fail on      (Next.js)
    spot map    leak)
```

Backends in v1: **Mem0** + a generic **vector store** (pgvector / Chroma / in-memory).
Architected for fast-follow: Zep / Graphiti and AWS Bedrock AgentCore.

## Explicitly deferred (fast-follow, NOT in v1)

- Runtime retrieval enforcement filter (latency-sensitive; ship after design partners ask).
- Zep + AgentCore adapters (architected for, built next).
- Audit receipts / compliance attestation layer (expansion path).

## Project layout

```
ferryte/
├── src/ferryte/            # Python core + CLI (pip install ferryte)
│   ├── instrument.py       # one-line auto-patching
│   ├── adapters/           # memory-backend adapters (Mem0, vector store, ...)
│   ├── lineage/            # source → derived-artifact graph + blast radius
│   ├── oracle/             # canary + scenario runner
│   ├── reports/            # coverage + blind-spot map
│   └── api/                # local HTTP server feeding the dashboard
├── dashboard/              # Next.js + Tailwind UI (Glyff design system, dark)
├── demo/                   # self-contained multi-tenant memory leak demo (the 30s X clip)
├── launch/                 # X thread copy, design-partner signup
└── tests/
```

## Source-available

Ferryte is **source-available** under the Business Source License 1.1.

- **Core (BSL 1.1, free to read / run / self-host)** — the library, CLI, four scenarios, lineage graph, Mem0 + vector adapters, local Next.js dashboard. Everything you need to verify forgetting in your own CI, in production, for free. Each version converts to Apache 2.0 three years after release.
- **Cloud (private beta)** — hosted continuous verification, regression alerts, multi-environment, Slack/PagerDuty integrations. Design partners only through 2026.
- **Enterprise (annual contract)** — self-hosted with SSO/RBAC/audit logs, premium adapters (AgentCore, Zep, GovCloud), signed compliance attestations (GDPR / CCPA), runtime retrieval enforcement (v2), support SLA.

The one thing BSL does not permit: reselling Ferryte as a hosted/embedded service that competes with Ferryte Cloud. Everything else — read, run, modify, self-host in production — is free. The exact boundary, contributor license, and trademark policy are in [LICENSING.md](LICENSING.md). The commercial-tier scope and how to apply are in [COMMERCIAL.md](COMMERCIAL.md).

Same model as Sentry, CockroachDB, HashiCorp, and MariaDB.

## Status

Pre-launch. The source-available engine ships now; Cloud and Enterprise gate behind design partners. Looking for B2B SaaS companies running multi-tenant AI agents in production with persistent memory.

If that is you: open an issue, email `hello@ferryte.dev`, or sign up via the marketing site.

## License

**v0.2.0 and later:** Business Source License 1.1, converting to Apache 2.0 three years after each release — see [LICENSE](LICENSE).
**v0.1.0 and earlier:** MIT (a published release cannot be relicensed) — see [LICENSE-MIT.txt](LICENSE-MIT.txt).
Commercial Cloud / Enterprise tiers are closed-source — see [LICENSING.md](LICENSING.md) for the precise boundary.
