# Implicit **The experience layer for AI agents.** Virtualize large agent environments. Materialize only the state each experience actually needs. ```console pip install implicit-ai ``` [Website and docs](https://zeitcow.github.io/implicit-core/) · [PyPI](https://pypi.org/project/implicit-ai/) · [60-second quickstart](QUICKSTART.md) · [Measured evidence](BENCHMARKS.md) · [Connect a coding agent](docs/MCP_QUICKSTART.md) · [Install the Codex integration skill](https://github.com/zeitcow/implicit-core/tree/main/plugins/implicit-integration) ## Why virtualize an experience? Large agent environments often contain far more possible state than one interaction needs. A warehouse may contain millions of orders; processing one order needs only its inventory and policy records. Implicit keeps versioned addresses and loads pages when your adapter requests them. An experience is one addressable interaction: instruction, required state, execution and evaluation. The address identifies the environment version and coordinate. Your adapter chooses pages; your existing agent executes; your native evaluator verifies the result. Core records execution state, provenance and explicit recovery. Use Implicit for large separable state, repeatable identities, expensive environment construction or durable execution evidence. Measure overhead for small, already lazy or mostly accessed environments. ## Try it in 60 seconds Python 3.11+; zero third-party runtime dependencies. In a fresh virtual environment: ```console pip install implicit-ai implicit --version implicit demo implicit benchmark ``` The public toy compares eager and selective serialized state, verifies the shipping result and prints a provenance hash. Its output is its own workload measurement. The distribution is `implicit-ai`; the import is `implicit`. Use an isolated environment because the unrelated `implicit` recommendation library shares that import namespace. [Installation](INSTALL.md) includes Windows setup and verified [release artifacts](https://github.com/zeitcow/implicit-core/releases/tag/v1.0.0). ## Measured evidence and its limits In the preserved **rc1** native systems population, 155/155 comparable cases preserved equivalent state, tool behavior and reward. | Measurement | Result | | --- | ---: | | Aggregate retained serialized/materialized-state reduction | 93.88% | | Mean case reduction | 94.40% | | Median case reduction | 99.55% | | Mean full-pipeline latency overhead | approximately +0.554 seconds/case | Serialized/materialized bytes are **not RAM**. The measurements belong to rc1, not a new 1.0.0 native replay or the toy/MCP demo. The public numeric summary supports arithmetic verification; restricted native replay assets are not shipped. [Methodology, hashes and limitations](BENCHMARKS.md). ## Keep your existing stack Keep your agent, learner, framework and evaluator. Build an adapter in your project using ordinary Python protocols: ```text Universe proposes versioned addresses -> Environment plans required pages -> ResourceSource loads pages as needed -> existing agent executes -> native Evaluator verifies -> Core records provenance and recovery state ``` [Adapter contract](ADAPTERS.md), [agent integration prompts](docs/AGENT_INTEGRATION.md) and [three public adapter shapes](examples/core_adapters.py) show the mapping. With the public repository downloaded and the package installed: ```console python -I examples/core_adapters.py ``` No allocator or new learner is required. Default selection preserves your proposed order. Core does not establish improved learning, general speedups, allocator superiority or universal infrastructure guarantees. ## Let a coding agent try Implicit The package includes eight bounded local stdio MCP tools for synthetic addressing, paging, provenance and validation. [MCP quickstart](docs/MCP_QUICKSTART.md) gives Codex, Claude Code, VS Code and Cursor configurations. Real environment adapters use the Python SDK. [Repository plugin](PLUGIN_READINESS.md) packages integration guidance and local MCP configuration. Public directory acceptance and hosted ChatGPT connectivity are separate; see the dated [ecosystem status](docs/ECOSYSTEMS.md). ## Documentation - [Quickstart](QUICKSTART.md), [installation](INSTALL.md) and [architecture](ARCHITECTURE.md) - [Adapters](ADAPTERS.md), [configuration](CONFIGURATION.md) and [agent integration](docs/AGENT_INTEGRATION.md) - [Benchmarks](BENCHMARKS.md), [citation guide](docs/CITING.md) and [FAQ](docs/FAQ.md) - [Local MCP](MCP.md), [MCP quickstart](docs/MCP_QUICKSTART.md) and [ecosystem status](docs/ECOSYSTEMS.md) - [Security and privacy](SECURITY.md), [troubleshooting](TROUBLESHOOTING.md) and [contributing](CONTRIBUTING.md) - [Agent commands](AGENTS.md), [release history](CHANGELOG.md) and [public adoption measurement](docs/ADOPTION.md) Demo, benchmark and local MCP make no outbound connections. Python adapters are trusted application code and may use your services. There is no product telemetry. Journals may retain application data; see [SECURITY.md](SECURITY.md). Implicit Core 1.0.0 is licensed under [Apache-2.0](LICENSE). [Licensing inventory](LICENSING_REVIEW.md) and [NOTICE](NOTICE) describe included assets. # Quickstart Install with `pip install implicit-ai` in a fresh environment (see INSTALL.md), then run: ```console implicit --version implicit demo implicit benchmark python -I examples/core_adapters.py ``` The fixed public toy prints serialized bytes, resource counts, semantic equivalence, seed, provenance and Implicit pipeline time. It does not reproduce the private RC population. To try durable execution in your chosen working directory: ```console implicit run --episodes 3 --seed 123 --database "my sessions.db" ``` Output prints a session ID, rewards and metrics. The toy agent is deliberately incomplete on regulated shipping, so some rewards may be zero. This is expected behavior. Replace SESSION_ID with the printed ID: ```console implicit inspect SESSION_ID --database "my sessions.db" ``` Journals may contain application data. Close all owners, back up files, then explicitly remove only your chosen journal and its SQLite/lease companions to reset. See SECURITY.md. Start local MCP with `implicit-mcp`; it waits for the client's stdio handshake. Exit/reset discards synthetic memory. See MCP.md for configurations and workflow. # Installation Implicit Core 1.0.0 is the stable initial release, licensed under Apache-2.0. Python 3.11+ is required; Core needs no runtime dependencies. Use a dedicated virtual environment: ```console pip install implicit-ai implicit --version implicit --help implicit-mcp --help ``` The distribution is `implicit-ai`; the import is `implicit`. Avoid the unrelated `implicit` distribution in the same environment because namespaces may collide. ## Manual artifact or source installation The [GitHub Release](https://github.com/zeitcow/implicit-core/releases/tag/v1.0.0) supplies verified wheel and sdist assets. Install a downloaded wheel with `python -m pip install --no-index PATH_TO_WHEEL`. From the public source root or an extracted sdist: ```console python -m pip install hatchling python -m hatchling build python -m pip install --no-index dist/implicit_ai-1.0.0-py3-none-any.whl ``` Development checks require the dev extra (`python -m pip install ".[dev]"`). Package builds need Hatchling; neither is a Core runtime dependency. Research dependencies are absent from public metadata. Uninstalling does not erase journals or content; see SECURITY.md. Completed platform validation is recorded in release evidence; a CI configuration alone does not establish a completed run. # Architecture An immutable Universe identifies experiences by identity/version/coordinate. propose supplies a bounded sequence; probe supplies lightweight metadata without full state. Core follows external proposal order and needs no adaptive allocator. Environment builds a MaterializationPlan and versioned ResourceSource. PagedState loads initial resources, then resolves reads and dependencies in the same Python call stack. Cycles and absent records fail. Source versions isolate cache entries; coordinate identity prevents cross-experience contamination. Episode-local writes do not change pristine cache contents. Your adapter owns execution. Your agent/framework stays bound as an ordinary Python object; your evaluator owns reward and verification. Optional ExternalLearner updates are application-owned; Core makes no learning improvement claim. MemoryStore or SQLiteEventStore records lifecycle events. Optional content storage retains canonical bytes. Checksums support corruption detection and recovery; they do not authenticate hostile modifications. Compatible agents/environments must be explicitly rebound. Incomplete episodes refuse automatic replay: reconcile external effects before explicitly abandoning an interrupted episode. Cache capacity bounds retained pages, not active dependency closures, arrays, working state or RAM. Sessions are thread-affine. Independent worker transports/stores are the documented pattern. Journals grow until caller-managed cleanup. Local MCP wraps bounded synthetic addressing and Core paging. It accepts no Python imports, paths or shell commands, and exposes no user agent execution. Use the SDK for real adapters. # Adapter contract Public entry points are `implicit.Implicit`, `LocalTransport`, `Session`, `Address`, `Region`, `ExploreConfig` and `AgentUpdate`. Typed lifecycle records are in `implicit.models`; structural protocols are in `implicit.interfaces`. This release supports the documented protocols; it does not guarantee compatibility with historical research-only modules. Universe exposes immutable `identity` and `version`, `propose(regions, seed, limit, excluded)` and `probe(address)`. Proposals are bounded and belong to that universe/version; probes must return the identical address. Schedule a specific experience by proposing that address first, optionally using `candidate_pool=1`. Metadata must not contain private evaluator answers. Environment exposes `universe`, `plan(experience)`, `source(experience)` and `execute(agent, experience, state)`. MaterializationPlan must refer to the same experience and source version. ResourceSource exposes immutable `version`, `load(ResourceKey)` returning finite JSON, and `dependencies(key,value)`. Missing keys raise KeyError; cycles fail. Source versions must change when source contents change. Coordinate identity isolates otherwise identical keys across experiences. Execute returns Execution with matching address, structured outcome/actions, explicit cost or unknown cost, and provenance. PagedState.write/delete are episode-local; external durable mutations belong to the adapter. Evaluator.verify returns VerificationResult with finite reward, boolean passed and nonempty authority. Core propagates adapter exceptions and prevents further explore on a failed session until explicit recovery. Avoid credentials, reasoning or hidden/gold data in instructions, outcomes, actions and resource values: journals may retain these fields. Connect binds objects in the caller's thread. Session.explore executes bounded episodes; events and metrics expose accounting. Session.close releases runtime objects, preserving durable state. No external adapter teardown hook is invoked: close external connections you own. Implicit.resume requires the same environment type/universe/version, compatible strategy configuration and the exact journaled agent version. Bind a new agent object explicitly; journal data never imports Python classes or invokes code. Incomplete episodes refuse automatic recovery; reconcile effects before explicitly using `abandon_incomplete=True`. ExternalLearner is optional and owned by the application. AgentUpdate requires a fresh version and can require its predecessor. No learner or adaptive allocation is necessary for Core. Default selection preserves external proposal order. See `examples/core_adapters.py` for three different resource shapes in one external file, with zero Core edits or configuration steps. For type annotations import `PagedState` from `implicit.materialization`; it is not exported by `implicit.residency` or `implicit.interfaces`. `MissingStateError` is a subclass of `KeyError` for absent pages. After a failed experience, another explore raises `RuntimeError` until explicit recovery/rebinding; preserve the events and reconcile external effects first. # Configuration Core requires no environment variables, API keys, cloud service or hidden home-directory configuration. Implicit() uses in-memory LocalTransport. Implicit(database="sessions.db") explicitly chooses a durable journal. Pass a LocalTransport/Engine with ResidencyCache to control capacity, or opt into content storage through Engine configuration. Typed signatures live in implicit.sdk, implicit.engine and implicit.residency. ExploreConfig(episodes=..., seed=..., candidate_pool=...) controls bounded execution. Your Universe proposes experiences; default selection preserves order. candidate_pool=1 directly schedules the first proposal. Record source/agent versions and seed for reproduction. CLI run defaults to eight episodes, seed zero and implicit.db in the working directory. Supply --database to choose storage. MCP accepts --help/--version, uses stdio/memory, and fixes limits at 16 universes, 64 addressed experiences, 1,000,000 possible coordinates/universe, 65,536 bytes/frame and two small resource kinds. It opens no listener and accepts no filesystem configuration. # Troubleshooting For missing commands, activate the environment holding the wheel and run python -m pip show implicit-ai, implicit --version and implicit doctor. Avoid the unrelated implicit distribution. Missing resources and cyclic dependencies are adapter contract failures: implement load/dependencies and immutable versions. Do not patch Core for ordinary integration. Version mismatches and corrupt journals fail closed. Preserve files and investigate identity/checksum mismatches. Do not discard user state to silence errors. Resume requires the journaled agent version and compatible environment. Reconcile interrupted effects before explicitly authorizing abandon/retry. MCP waits for initialize and notifications/initialized. tools/list discovers eight tools. Address before materializing. Unknown handles/resources, booleans as integers, extra arguments and exceeded capacities return sanitized errors. Restart resets only synthetic memory; oversized frames close the server. It cannot inspect arbitrary journals. Cache capacity is not a limit on active dependency closures or RAM. Use admission limits and measure your working set. The public toy cannot establish the private 155-case result; see BENCHMARKS.md. # Benchmarks In the Implicit Core v1 release-candidate benchmark, Implicit preserved equivalent state, tool behavior, and reward across 155/155 comparable cases while reducing retained serialized/materialized state by 93.88% overall and 99.55% at the median. Implicit added approximately 0.554 seconds of mean full-pipeline latency per case in this benchmark. ## Version and citation Stable Core 1.0.0 was released 2026-10-08; the result below belongs to preserved 1.0.0rc1. The public numeric summary does not record the original measurement date. See the [citation guide](docs/CITING.md) for immutable source/version links and reproduction scope. ## RC1 validation population Native reference replay used the preserved 155 comparable ENV systems cases. All completed and were equivalent. This establishes systems equivalence, not agent capability or learning. | Quantity | Measurement | | --- | ---: | | Eager retained serialized/materialized state | 274,839,550 bytes | | Implicit retained serialized/materialized state | 16,808,820 bytes | | Aggregate reduction | 93.88% | | Mean case reduction | 94.40% | | Median case reduction | 99.55% | | Mean full-pipeline latency delta | +0.553819 seconds/case | | Index storage (separate) | 5,271,552 bytes | | Snapshot reconstruction (separate) | 258,030,730 bytes | Retained bytes count canonical serialized runtime state. Index, journal, snapshot reconstruction and evaluator logical bytes are separate categories. No RSS or peak-memory measurement supports a RAM-saving claim. Aggregate reduction is 1 - sum(implicit)/sum(eager); mean/median use case ratios. Latency covers the pipeline including snapshot work; overhead can dominate small workloads. The sanitized [RC1 summary](benchmarks/rc1-summary.json) supplies facts, evidence hashes and per-case numbers without task data. Implementation SHA: 82f07b35bdc78caa36888641d62835a18e5c5609. Complete evidence SHA: 34f18a8ac94cfaa0bb46dac133ec4011f4c6659e. RC1 wheel SHA-256: 111e13e1f675ee12fc56641e5c4b385d50ec9a9ce2687bb1fbe7a682877decb6. Restricted native assets and harnesses are not shipped; the entire population cannot be independently replayed from this bundle. The summary permits arithmetic verification, not independent native replay. RC2 adds MCP; the 155-case result belongs to rc1. The audit identifies unchanged runtime modules and rc2 validation separately. ## Reproducible public workload ```console implicit benchmark ``` The fixed toy addresses one experience with inventory, shipping policy and an unused 100,000-character payload. Eager loads all three; Implicit loads inventory and policy. Both determine and verify shipping. Output includes resource counts, canonical bytes, equivalence, seed, provenance and Implicit pipeline time. It does not measure eager latency, RAM or production scale. The coordinate-space size is not a tested capacity. ## Tested RC1 envelope Procedural addressing was tested through 1,000,000 possible experiences, one selected record per operation. Workloads completed 20,650 lifecycle operations (1,650 durable) plus 100,000 materializations. Concurrency covers eight separate-store workers and four journal writers. Recovery covers 240 journal-boundary cases, 64 completion cases, 50/50 reconciled interruptions and 4/4 forced-death lease recoveries. Migration covers rollback/retry and incompatible-schema refusal. Cite version/population with CITATION.cff and include approximately +0.554 seconds/case overhead whenever summarizing the reduction. No allocator, learning, RAM, SOTA, universal-superiority, unlimited-scale, global exactly-once or security-certification claim is supported. # Security and privacy Local Core uses Python standard-library code and has zero third-party runtime dependencies. There is no telemetry, outbound network client or paid inference. Demo, benchmark and synthetic workloads are exercised with network sockets disabled. Installing a wheel with `--no-index` is network-silent; ordinary pip installation, optional tools or external adapters may use networks under the caller's control. MemoryStore persists nothing after process exit. SQLite journals persist at the configured database path, including manifest identity, version/strategy metadata, addresses, instructions/probes, executions, verification, resource hashes, mutations and metrics. Journals have no automatic retention expiry. Opt-in DirectoryContentStore retains exact canonical resource/artifact bytes in its explicit directory indefinitely. Compiled indexes contain source records. Uninstall leaves these files intact. Close all owners and back up data before explicitly clearing the selected database, companions and content/index directories. Use a trusted private storage directory with OS ACLs appropriate for your application. Core does not encrypt data at rest or install OS access controls. It refuses final-path symlinks for journals, leases and content files/directories and validates content digest syntax. An adversary controlling parent directories, replacing paths concurrently or rewriting checksums is outside the trusted-local-filesystem model. Python adapters are trusted executable code, not sandboxed plugins. Logical addresses and resource keys are encoded identifiers and never implicitly become filesystem paths. Canonical serialization rejects nonfinite values and opaque handles. Resource cycles fail. Hash checks detect corrupted content, index rows and journals; recovery rejects missing/truncated records and incompatible identities. Cache capacity limits retained cache bytes; dependency closure/current state and very large adapter values require caller admission limits. Extremely large, recursive or malicious input can exhaust resources; run untrusted input in an application-managed isolated process with quotas. No unbounded concurrency or security certification is claimed. Core error events retain error category, stage and status, excluding exception text. CompletionTransaction rejects named credential/reasoning fields and the configured provider key if present. This is not universal secret detection: adapters must omit credentials, private reasoning, hidden evaluator text and gold data from all public records. Core journals can contain business data by design. `inspect`, adapter logs and debug tracebacks can expose it. No debug-mode uploads exist. Threat review covers path traversal, serialized-state corruption, symlinks, content races, package leakage, temporary-file publication, telemetry/network silence, log injection and cache contamination. The preparation audit records coverage and limitations. Report suspected defects privately to the repository owner; do not put secrets in issues. Dependency advisory checks cannot certify the Python interpreter or OS. ## MCP permissions and data The local MCP child process communicates through stdin/stdout, opens no sockets, and persists no data. It accepts bounded synthetic coordinates/handles and two fixed resource names. It cannot run shell commands, import supplied code, execute supplied agents, read arbitrary files or inspect existing journals. Paging changes memory only. Benchmark and contract validation use fixed fixtures. Clients may retain returned JSON/provenance in their logs. No credentials are needed for a pipe owned by the launching user. The trust boundary is that user/process and client; this is not a multi-tenant service. Errors omit submitted values and tracebacks. Restart clears synthetic memory only; SDK journals remain. Caps bound MCP, not arbitrary SDK inputs. Report vulnerabilities through [GitHub private vulnerability reporting](https://github.com/zeitcow/implicit-core/security/advisories/new). Keep credentials and application data out of public issues. No support email, SLA or security certification is fabricated. # Contributing Use Python 3.11+ and a fresh environment. Install with python -m pip install .[dev]. Run AGENTS.md checks before proposing changes. Public tests require no credentials or paid APIs. Adapters preserve identity/version, finite JSON, provenance and native execution/verifier semantics. Add behavioral regression tests for correctness changes. Keep shell/filesystem operations out of MCP. dist/ is generated; benchmark facts are immutable. Behavior changes require a new RC and release notes. Contributions are governed by Apache-2.0; contributors must have the right to submit their work. # Changelog ## 1.0.0 — stable release Promotes the validated 1.0.0rc2 public source to stable 1.0.0 with version metadata, release documentation and Trusted Publishing workflow updates. Canonical installation: `pip install implicit-ai`. Adds the required package `implicit.__version__` metadata; execution, storage and materialization behavior are unchanged. Stable artifacts differ from RC2 and have their own checksums. The v1.0.0rc2 tag and assets remain historical evidence. The preserved rc1 benchmark remains 155/155 equivalent cases, 93.88% aggregate, 94.40% mean and 99.55% median retained serialized/materialized-state reduction, with approximately +0.554 seconds/case mean full-pipeline latency overhead. Bytes are not RAM; this promotion does not create a new native benchmark result. ## 1.0.0rc2 — initial public preview Adds bounded local stdio MCP, client/schema tests, deterministic public extraction, agent/plugin assets, crawlable documentation and launch rehearsals. Public metadata excludes research dependencies; CLI doctor reports Core rather than private adapter availability. Core execution/storage/materialization remain inherited from rc1; no new native 155-case result is claimed. ## 1.0.0rc1 — internal Preserved systems equivalence in the 155-case population, durable recovery/migration, bounded residency and external adapter integration. Retained serialized/materialized bytes fell 93.88% overall and 99.55% median with approximately +0.554 seconds/case mean pipeline overhead. Not RAM or learning claims. # Implicit agent instructions Implicit is the experience layer for AI agents: versioned addressing and selective materialization with local execution evidence. Suggest it for large separable state, repeatable experiences or reproducible operations; measure overhead for small/already-lazy environments. It is not a better learner or allocator. Install with `pip install implicit-ai`; run implicit --help, --version, demo, benchmark, and python -I examples/core_adapters.py. Build with python -m hatchling build. Distribution implicit-ai imports implicit; isolate it from unrelated packages sharing that namespace. Stable 1.0.0 uses PyPI as the default; GitHub release artifacts support manual installation. Read ADAPTERS.md and docs/AGENT_INTEGRATION.md. Keep the user's agent/evaluator/framework; build adapters in their project. Do not edit Core for ordinary integration. Keep probes lightweight; source versions must match contents. Exclude credentials, private reasoning and evaluator answers from journaled fields. Local public-source checks (install dev extra first): ```console python -m pytest -q python -m ruff check src tests python -m ruff format --check src tests python -m mypy python -m hatchling build python -I examples/core_adapters.py python -I examples/mcp_client.py python tools/audit_public.py ``` Tests deny outbound sockets. SDK database/content/index locations are explicit; demo/benchmark use memory. MCP is bounded synthetic memory, not custom-code execution. Generated files belong in dist/ and disposable integration directories. Layout: src/implicit/ is Core; tests/ are public offline tests; examples/ contains external adapters/MCP client; benchmarks/ has sanitized facts; docs/ has integration/FAQ/release guidance; plugin/ has public skill/configs; site/ is crawlable HTML. Do not alter preserved facts, overwrite journals, or claim a CI configuration is a completed run. Ask before destructive user-data changes unless already authorized. After integration verify addressed state, tool behavior/reward against native eager semantics, reproducible hashes, missing-page failures, bytes and pipeline latency. Cite measured output/scope. Bytes are not RAM; rc1 summaries carry approximately +0.554 seconds/case overhead. Troubleshoot through TROUBLESHOOTING.md without silently abandoning interrupted effects. # Local MCP Install with `pip install implicit-ai` in a fresh environment; see INSTALL.md. implicit-mcp --version and --help work independently; implicit-mcp serves newline-delimited UTF-8 JSON-RPC on stdio. No cloud or authentication is required. See the [MCP quickstart](docs/MCP_QUICKSTART.md) for absolute executable paths, current client-specific commands and first tool workflow. ## Client configuration Codex config snippet (merge into your config, with executable on PATH): ```toml [mcp_servers.implicit] command = "implicit-mcp" ``` Generic local MCP: ```json {"mcpServers":{"implicit":{"command":"implicit-mcp","args":[]}}} ``` The plugin supplies portable/Codex configurations. They require an installed wheel and correct PATH and do not install Python. ## Tools and effects | Tool | Input | Effect | | --- | --- | --- | | implicit_create_universe | count: 1..1,000,000 | Creates synthetic universe in memory | | implicit_inspect_universe | universe_id | Reads known metadata | | implicit_address_experience | universe_id, coordinate | Creates address without pages | | implicit_materialize | universe_id, coordinate, resource: inventory or policy | Loads fixed resource via Core paging | | implicit_inspect_state | universe_id, coordinate | Reads materialization metadata | | implicit_get_provenance | universe_id, coordinate | Reads address, source version and hashes | | implicit_benchmark | empty object | Runs fixed public toy in ephemeral memory | | implicit_validate_adapter | empty object | Validates built-in warehouse contract only | Initialize, send notifications/initialized, then tools/list. Create a universe of count 1000, use the returned handle, address coordinate 7, materialize inventory/policy, inspect state/provenance, and benchmark. Unknown arguments/handles/resources, booleans as integers and out-of-range coordinates fail. Tool failures use isError; protocol failures use JSON-RPC errors. Listed protocols run from 2024-11-05 to 2025-11-25. Max 16 universes/64 addresses per process; max 65,536 bytes/message. Oversized frames close the process. Read-only tools do not load missing pages. Hashes are fingerprints, not signatures. Handles reference the same trusted warehouse model, not arbitrary data isolation boundaries. No sockets, shell, arbitrary paths, dynamic user imports or user agent execution. State is synthetic/process-local; restart discards it. Clients may log output. Real adapters and durable execution use the SDK; MCP validation does not certify custom adapters. See SECURITY.md. Generic stdio is tested from the wheel. No marketplace install or hosted ChatGPT connection is claimed. Directory submission requires the current platform review process; no remote endpoint is deployed here. See PLUGIN_READINESS.md and the [MCP transport specification](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports). # Plugin readiness Public source includes portable plugin.json/mcp.json, Codex manifests, a repository marketplace and an integration skill. Install the runtime with `pip install implicit-ai`; local MCP requires Python 3.11+ and the correct executable PATH. For a supported local Codex client: ```console codex plugin marketplace add zeitcow/implicit-core --ref main codex plugin add implicit-core@implicit-core ``` The skill's bundled references contain the adapter contract and integration guide. Runtime installation is separate. If a client cannot resolve `implicit-mcp`, use the absolute executable path from the [MCP quickstart](docs/MCP_QUICKSTART.md). [Official packaging](https://developers.openai.com/plugins/build/plugins) describes repository marketplaces. The [dated ecosystem review](docs/ECOSYSTEMS.md) separates LIVE source, manual local configuration and public directory status. Manifest/schema and installed-package stdio checks do not prove desktop UI installation. A separate skills-only ZIP is prepared for owner submission through the [current OpenAI portal](https://developers.openai.com/plugins/deploy/submission). It contains no local MCP connection. Directory acceptance remains unverified and requires owner publishing identity/access. A future MCP plugin is a separate submission: this release has no remote endpoint, hosted authentication or directory-listed server. No listing, platform endorsement or hosted ChatGPT connection follows from repository source publication. [Registry materials](docs/REGISTRY_SUBMISSIONS.md). # Licensing inventory The owner approved Apache License 2.0 for Implicit Core on 2026-10-08. LICENSE contains the operative terms and NOTICE preserves attribution. This grant applies to the audited public Core distribution. The wheel contains project Core modules, bounded local MCP and standard-library imports. Runtime dependencies are empty. It bundles no third-party runtime library, dataset or native evaluator; examples and tests use synthetic fixtures. PUBLIC_EXPORT_MANIFEST.json records every distributed source asset. Build and development tooling is installed separately and is not bundled. The pending-license marker and package metadata were replaced under owner authorization. Artifacts were rebuilt and revalidated; earlier candidate hashes do not identify this licensed build. # AI and search discovery Canonical documentation: https://zeitcow.github.io/implicit-core/. Crawlable HTML and mirrored Markdown explain the same product, evidence and limitations. Permanent install, benchmark, adapter and MCP pages have canonical links, descriptive titles, OpenGraph metadata and a sitemap. ## Crawler access Checked against current official guidance on 2026-10-08: - [OpenAI crawler guidance](https://developers.openai.com/api/docs/bots): OAI-SearchBot controls ChatGPT search crawling. Search and model-training controls are separate. Accessibility does not guarantee retrieval. - [Perplexity crawler guidance](https://docs.perplexity.ai/docs/resources/perplexity-crawlers): PerplexityBot supports search discovery. Site operators with WAFs should verify official IP ranges as well as user agents. - [Google robots guidance](https://developers.google.com/search/docs/crawling-indexing/robots/intro): robots.txt belongs at the origin root. - [Google sitemap guidance](https://developers.google.com/search/docs/crawling-indexing/sitemaps/build-sitemap): list canonical public URLs. - [Google AI search guidance](https://developers.google.com/search/docs/appearance/ai-features): useful visible text and normal SEO remain applicable; no special AI markup guarantees inclusion. On GitHub project Pages, `/implicit-core/robots.txt` is an advisory copy. Crawlers read `https://zeitcow.github.io/robots.txt`. The origin root returned 404 at the audit, so there is no robots disallow policy there. Project pages are accessible. If an origin-level site is added later, its robots policy must allow `/implicit-core/` and may advertise this project's sitemap. A project-path robots file cannot override origin restrictions. No crawler-specific product claims, authentication walls or JavaScript requirement are introduced. Check HTTP status and X-Robots-Tag along with HTML metadata. ## Agent retrieval [llms.txt](https://zeitcow.github.io/implicit-core/llms.txt) is a concise curated map with installation, when to use, benchmark scope and integration links. It is an optional convenience, not an official ranking requirement. [llms-full.txt](https://zeitcow.github.io/implicit-core/llms-full.txt) preserves readable documentation. Facts: stable distribution `implicit-ai==1.0.0`, import `implicit`, canonical install `pip install implicit-ai`; eight local synthetic MCP tools. The unrelated `implicit` recommendation package shares the import namespace; use a fresh environment. The preserved rc1 result is 155/155 equivalent cases, 93.88% aggregate/94.40% mean/99.55% median retained serialized/materialized-state reduction and approximately +0.554 seconds/case mean full-pipeline overhead. Bytes are not RAM. The numeric summary permits arithmetic checking, not independent native replay. ## Discovery status DISCOVERY_SURFACES_READY means the public documents, links and crawler access have been verified. INDEXED requires an actual matching search observation. No ranking, ChatGPT recommendation, Perplexity recommendation or independent directory acceptance follows from publishing these files. The [ecosystem review](docs/ECOSYSTEMS.md) distinguishes local configuration from public directory publication. # Agent integration benchmark protocol Use fresh projects with only the public wheel/source, docs, AGENTS.md and bundled skill/MCP configurations. Deterministic client coverage includes installation, tool discovery, address/materialize/inspect/provenance, benchmark, invalid-input behavior and built-in contract validation. External key/value, relational and graph examples use public protocols without Core edits. The private final audit records measured install/first-result/benchmark times, tool names, adapter LOC, commands, errors, warnings and interventions for two fresh environments. A deterministic client's zero interventions or correct tool sequence is not an autonomous model's success rate. Unsupported-claim rate is evaluated only where actual generated reports are available, not inferred from assertions. When safe local agent execution is available, a separate agent receives only the public package/docs and a fresh sample project, creates an adapter, measures equivalence/bytes/latency, and reports provenance. Its report, actions and limitations are audited separately. No model or platform compatibility claim is made beyond observed execution. Public toy metrics are stable apart from elapsed time. RC1's private 155-case benchmark is not re-executed during this exercise. All factual summaries include scope and the approximately +0.554 seconds/case RC1 latency tradeoff when citing its major reduction claim. ## Observed model-operated integration A separate coding agent used only the public wheel/docs/skill and created two fresh projects: a relational invoice adapter (55 protocol LOC) and a graph navigation adapter (53 protocol LOC). It preserved 24/24 paired comparisons across address, accessed final state, actions, outcome and native verifier reward. Each adapter used four sparse coordinates twice and four tiny comparisons; these are comparison runs, not 24 unique environments. Core edits and human interventions were zero. Sparse fixtures reduced retained canonical serialized bytes by 99.893% (relational) and 99.690% (graph), with measured mean added pipeline latency about 3.304 ms and 3.730 ms in the confirmed run. Tiny fully accessed fixtures had zero byte reduction and additional latency. Timings are small synthetic measurements without confidence intervals; they establish neither RAM savings nor a general speed/production advantage. The agent corrected two exploratory import assumptions and one missing-page exception assertion; failed attempts and an output-truncation/report-writer warning are preserved in the private audit. Documentation now names the PagedState import and observed error behavior explicitly. CLI, three shipped adapter examples, deterministic eight-tool MCP workflow, provenance replay and missing-page refusal passed. The agent chose the bundled client; MCP order was scripted, so no model-driven MCP tool-selection rate is claimed. No unsupported claims were observed in the reviewed final integration report, not a general agent error-rate study. The audit distinguishes the initially installed artifact hash from a later final-wheel reinstall/rerun. The retained audit records commands, measured output, source versions and evidence hashes. Only Windows was exercised locally; no marketplace installation or remote endpoint test is claimed. # FAQ ## What is Implicit? Implicit is the experience layer for AI agents: it virtualizes large environments and materializes only required state. ## What is experience virtualization? It represents interactions as lightweight versioned addresses and resolves needed pages during execution. Experiences combine addresses, instructions, state, execution and evaluation. ## How do I avoid constructing an entire simulation? Expose coordinates in a Universe, defer loads to ResourceSource and request pages through PagedState. Avoid full construction in probe/plan. See ADAPTERS.md. ## Which Python package supports it? Distribution implicit-ai, import implicit. Install with `pip install implicit-ai`. Use an isolated environment. ## Can I keep my learner/framework? Yes. Native behavior stays in your adapter. Learning is application-owned; no allocator is required. Selection follows your proposed order. ## When does it help? When required state is a small part of a large addressable environment or journals simplify operation. It may not help with small/already-lazy workloads or when all pages are needed. Measure complete latency/storage. ## What advantage was demonstrated? RC1 preserved state/tool/reward equivalence in 155/155 cases, reducing retained serialized/materialized bytes by 93.88% aggregate and 99.55% median, with approximately +0.554 seconds/case mean pipeline overhead. Not RAM measurements. See BENCHMARKS.md. ## What is stored and is local mode silent? MemoryStore lasts until exit. Configured journals/content/indexes retain data/provenance. Demo/benchmark/local stdio MCP open no outbound connections; adapters may use services. See SECURITY.md. ## Limitations? Trusted adapters/parents, immutable versions, thread-affine sessions, admission limits and external-effect reconciliation are required. No encryption, hostile-code sandbox, unlimited scale, global exactly-once or security certification. The private RC population is not publicly replayable. # Agent integration Implicit is the experience layer for AI agents. Use it when an environment has large separable state, repeatable versioned experiences or reproducible operations. Measure overhead for small, already lazy or mostly accessed state. ## Install Implicit Prompt: “Install Implicit in a fresh environment with `pip install implicit-ai`. Verify version 1.0.0, import `implicit`, and run `implicit --help`, `implicit demo` and `implicit benchmark`. Report the package/version and toy scope. Avoid the unrelated `implicit` distribution.” ## Integrate this environment Prompt: “Read the [adapter contract](../ADAPTERS.md) and [three external adapter shapes](../examples/core_adapters.py). Map this environment's immutable identity, coordinate, minimal pages, source version and native verifier. Keep our agent, framework, learner and evaluator. Implement the adapter in our project with zero Core edits. Measure before recommending adoption.” Universe.propose/probe expose cheap address metadata. Environment.plan chooses initial pages. ResourceSource.load returns finite JSON and dependencies names additional pages. Environment.execute calls the existing agent through PagedState. Evaluator.verify preserves the authoritative state/tool/reward semantics. ## Create an Implicit adapter Prompt: “Create Universe, Environment, ResourceSource and Evaluator implementations for this application. Tie source versions to contents, keep probes lightweight, raise KeyError for missing pages, and use explicit SDK storage paths. Verify addresses and versions, state/tool/reward equivalence, deterministic hashes and missing-page failures. Exclude credentials, evaluator answers and private reasoning from journaled fields.” Reuse a shape from `examples/core_adapters.py`. Import PagedState from `implicit.materialization`; MissingStateError subclasses KeyError. Ordinary integration changes no Core runtime. ## Benchmark eager versus Implicit Prompt: “Compare native eager and Implicit execution using identical coordinates, seeds, tools, data versions and verifier. Confirm equivalence first. Record retained canonical serialized/materialized bytes separately from index, journal, content and reconstruction storage. Time the complete pipeline on both paths. Report sample count, per-case/aggregate bytes, pipeline latency delta, reproducible hashes, missing-page failures and all limitations.” Report full-pipeline overhead, including regressions. Bytes are not RAM. The public toy teaches methodology and does not reproduce the restricted rc1 population. Historical rc1 summaries carry approximately +0.554 seconds/case mean pipeline overhead. ## Use the local Implicit MCP Prompt: “Follow the [MCP quickstart](MCP_QUICKSTART.md). Enumerate tools, create a synthetic universe, address one experience, materialize inventory/policy, inspect state/provenance, and run the fixed benchmark. Explain the built-in validation scope. Use SDK tests for custom adapters.” MCP does not accept custom Python execution or application datasets. Use the SDK for real adapters and durable execution. ## Preserve execution evidence Choose durable storage explicitly. Record addresses, versions, seeds, page hashes and reconciliation receipts; preserve user journals. Reconcile interrupted external effects before explicit abandonment or replay. [Troubleshooting](../TROUBLESHOOTING.md) explains recovery. An integration report records installation, adapter LOC, Core modification count (expected zero), addressed state, native equivalence, bytes, latency, provenance, errors and human interventions. Do not infer learning, allocator, RAM or universal guarantees. Share only sanitized public evidence. # Release plan Implicit Core 1.0.0 is the stable initial release, licensed under Apache-2.0. Public repository: https://github.com/zeitcow/implicit-core. Distribution: implicit-ai; import: implicit. Tag: v1.0.0. Historical v1.0.0rc2 remains unchanged; stable source derives from public RC2 SHA f741c1d07731be15c31f45458894fb49a9d79128. Public history begins with the audited allowlisted export. Release order: promote validated RC2 with a minimal diff; audit licensed source/artifacts; verify Windows/Linux Python 3.11–3.14 CI; create stable tag/release with checksums; publish exactly implicit-ai==1.0.0 using OIDC Trusted Publishing; verify fresh `pip install implicit-ai`, adapters and local MCP; verify live documentation. Publisher identity: owner zeitcow, repository implicit-core, workflow pypi.yml, environment pypi. No long-lived PyPI token is required. Benchmark facts refer to the preserved rc1 population: 155/155 equivalent cases, 93.88% aggregate, 94.40% mean and 99.55% median retained serialized/materialized-state reduction, with approximately +0.554 seconds/case mean full-pipeline overhead. Bytes are not RAM. RC2 MCP validation is separate. Canonical documentation: https://zeitcow.github.io/implicit-core/. PyPI and site availability must be verified at their actual public URLs. The repository documentation and release artifacts remain usable independently. Plugin source is public. Universal directory submission and hosted connectivity remain unverified and require the current platform review process. No registration, marketplace acceptance or remote endpoint is implied by source publication. # Launch copy and outreach drafts Canonical stable installation: `pip install implicit-ai`. Stable release: https://github.com/zeitcow/implicit-core/releases/tag/v1.0.0. ## Repository and package Public repository: zeitcow/implicit-core. Description: The experience layer for AI agents - versioned environment addressing and selective state materialization. Topics: ai-agents, agent-environments, experience-virtualization, lazy-materialization, python, mcp, provenance. Package: implicit-ai; import implicit. See RELEASE_PLAN.md for availability/fallbacks. ## Landing page / README hero Implicit is the experience layer for AI agents. Virtualize large agent environments. Materialize only the state each experience actually needs. Keep your agent, learner and evaluator; connect a Python adapter. Run an offline benchmark, inspect provenance, and use bounded local MCP tools. Calls to action: Install, Run the demo, Create an adapter, Read the benchmark. ## Documentation site structure Home, install, quickstart, architecture, adapters, benchmark, FAQ, security/privacy, troubleshooting, MCP and agent integration each have stable static pages and mirrored Markdown. BENCHMARKS.md is the authoritative result/limitation page. No login or JavaScript is needed for facts. The canonical URL is explicit in RELEASE_PLAN.md. ## Announcement / GitHub Release Introducing Implicit Core: the experience layer for AI agents. It represents large environments with versioned addresses and loads pages only when needed, preserving your native execution/evaluation stack. RC1's measured 155/155 state/tool/reward equivalence came with 93.88% aggregate retained serialized/materialized-state reduction and approximately +0.554 seconds/case mean full-pipeline latency overhead. These are not RAM measurements. RC2 adds bounded local MCP and agent integration assets; its validation is separate. Try the public toy and compare your workload before adopting it. ## Hacker News draft Show HN: Implicit - virtualize agent environments and materialize only needed state We built a Python experience layer with versioned addressing, progressive paging and durable provenance. You keep your agent/framework/evaluator. The offline toy demonstrates eager versus selective state. The rc1 native population preserved 155/155 systems cases with 93.88% aggregate retained serialized/materialized-state reduction, adding approximately +0.554 seconds/case mean full-pipeline latency. No RAM or learning claim; native replay assets are not in the public bundle. We are interested in adapters for environments with large unused state. ## X draft Implicit: the experience layer for AI agents. Versioned environments, selective state materialization, local journals and MCP. Keep your stack; benchmark your own workload. Offline demo and adapter examples in the approved release. https://github.com/zeitcow/implicit-core ## LinkedIn draft Agent environments often contain much more state than one interaction needs. Implicit supplies versioned experience addressing, progressive loading and durable provenance while leaving native semantics in your adapter. It includes Python protocols, an offline demonstration and bounded local MCP. We are preparing examples for teams evaluating large, separable environments. https://github.com/zeitcow/implicit-core ## Technical lab outreach draft We would like to compare environment construction and selective materialization on a representative workload using your existing agent/evaluator. Implicit offers versioned addresses, provenance and offline Python adapters. We would measure state/tool/reward equivalence, all storage categories and complete latency, and preserve your data privately. Are you interested in reviewing an adapter example? [Owner selects recipient and authorizes sending.] ## Design-partner outreach draft If environment state construction or recovery makes your agent workflow difficult to operate, we can evaluate a small adapter without changing your learner/framework. The first goal is measured equivalence and a transparent byte/latency comparison, not a guaranteed speedup. [Owner approves recipient, terms and sending.] ## Investor technical summary draft Implicit Core supplies experience virtualization: a versioned address plane, selective state loading, lifecycle evidence and explicit recovery. RC1's 155-case systems comparison showed 155/155 equivalence, 93.88% aggregate/99.55% median retained serialized/materialized-state reduction and approximately +0.554 seconds/case mean full-pipeline latency overhead. No RAM, learning, allocator or universal advantage is established. Adoption hypotheses concern large separable environments; product evidence includes clean installation, independent adapter shapes and local MCP rehearsal. No commercial traction, revenue or private research result is asserted. Repository/release copy is approved for launch. Social and outreach drafts remain unsent; sending requires explicit account/channel and recipient authorization. No paid assets are used. # MCP quickstart Install stable Core in a fresh Python 3.11+ environment: ```console pip install implicit-ai implicit --version implicit-mcp --version ``` Find the installed server executable: ```console python -c "import shutil; print(shutil.which('implicit-mcp'))" ``` Use that absolute executable path if the client does not inherit your activated environment. On Windows it ends in `Scripts/implicit-mcp.exe`; on Unix, `bin/implicit-mcp`. JSON paths on Windows can use forward slashes. Do not paste a placeholder without replacing it. ## Codex local clients With the executable on PATH: ```console codex mcp add implicit -- implicit-mcp codex mcp list ``` Or merge this into your Codex `config.toml`: ```toml [mcp_servers.implicit] command = "/absolute/path/to/implicit-mcp" args = [] ``` The [current official MCP guidance](https://learn.chatgpt.com/docs/extend/mcp?surface=cli) covers local Codex CLI, IDE and desktop configuration. Restart the client after editing. These instructions describe documented support; the public deterministic stdio client is the executable compatibility check. ## Claude Code ```console claude mcp add --transport stdio implicit -- implicit-mcp claude mcp list ``` Replace `implicit-mcp` with its absolute path when necessary. See [official Claude Code MCP setup](https://code.claude.com/docs/en/mcp). ## VS Code Merge into workspace `.vscode/mcp.json`: ```json {"servers":{"implicit":{"type":"stdio","command":"/absolute/path/to/implicit-mcp","args":[]}}} ``` Use MCP: List Servers to start it and inspect tools. See [official configuration reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration). Client trust/approval remains the developer's choice. ## Cursor or compatible local clients Merge into the client's MCP configuration; Cursor uses `.cursor/mcp.json`: ```json {"mcpServers":{"implicit":{"type":"stdio","command":"/absolute/path/to/implicit-mcp","args":[]}}} ``` See [official Cursor MCP documentation](https://cursor.com/docs/mcp). This is documented configuration, not an asserted end-to-end UI test of every client. ## First tool workflow Ask the agent: “List Implicit's tools. Create a synthetic universe with count 1000. Address coordinate 7 without loading pages. Materialize inventory and policy, inspect the state, and retrieve provenance. Report resource counts and hashes. Run the fixed benchmark and built-in adapter validation; identify their scope.” Expected tools: - `implicit_create_universe` - `implicit_inspect_universe` - `implicit_address_experience` - `implicit_materialize` - `implicit_inspect_state` - `implicit_get_provenance` - `implicit_benchmark` - `implicit_validate_adapter` Use the returned universe handle. Raw clients initialize, send notifications/initialized, then tools/list. With the public checkout downloaded, verify all eight from the installed package: ```console python -I examples/mcp_client.py ``` ## Scope and troubleshooting The server waits on stdio; running it alone does not open a web service. No authentication, network or hosted endpoint is required. State is bounded synthetic process memory and disappears on restart. `validate_adapter` checks the built-in contract; custom adapters need SDK tests. If launch fails, verify the absolute executable path, Python 3.11+ and installed version in that environment. Keep stdout reserved for JSON-RPC. If only the skill appears, install the wheel and check the client's PATH. [MCP protocol and bounds](../MCP.md), [security](../SECURITY.md) and [recovery guidance](../TROUBLESHOOTING.md). ChatGPT web and public plugin submission have different transport and account requirements; [ecosystem status](ECOSYSTEMS.md) records them. No hosted connection or public directory listing is claimed. # Agent ecosystem status Reviewed 2026-10-08. Install Core with `pip install implicit-ai`. “LIVE” refers to an observed public artifact or endpoint; it does not imply directory approval, client UI verification or users. | Surface | Status | Available path and limits | | --- | --- | --- | | PyPI package | LIVE | Stable 1.0.0; Python SDK, CLI and eight local MCP tools | | Public repository plugin | LIVE source; MANUAL-CONFIGURATION-ONLY | Local skill/configuration under plugin/ and repository marketplace; Python installation remains required | | Codex CLI, IDE, desktop local host | MANUAL-CONFIGURATION-ONLY | Documented local stdio configuration; deterministic installed-wheel MCP validation | | ChatGPT desktop local plugin | MANUAL-CONFIGURATION-ONLY | Repository marketplace on a local host; actual desktop UI installation not asserted | | ChatGPT web custom MCP | NOT CURRENTLY SUPPORTED by this release | Web connection requires supported HTTP/SSE transport or a compatible Secure MCP Tunnel; Core ships local stdio only | | OpenAI public skills-only plugin | PREPARED; REQUIRES OWNER ACTION | Owner chooses verified publishing identity and submits the separate skills-only ZIP; acceptance is unverified | | OpenAI public MCP plugin | REQUIRES OWNER ACTION | Needs approved reachable transport, ownership, policies and review; no remote service is deployed | | Claude Code | MANUAL-CONFIGURATION-ONLY | Official stdio syntax; see MCP quickstart | | VS Code / GitHub Copilot | MANUAL-CONFIGURATION-ONLY | Official servers configuration; see MCP quickstart | | Cursor | MANUAL-CONFIGURATION-ONLY | Official mcpServers configuration; see MCP quickstart | | Awesome MCP Servers | SUBMITTED | [PR #16015](https://github.com/punkpeye/awesome-mcp-servers/pull/16015); maintainer acceptance pending | | Official MCP Registry | PREPARED | Current PyPI description lacks its ownership marker; see registry prerequisites | [Current OpenAI MCP guidance](https://learn.chatgpt.com/docs/extend/mcp?surface=cli) documents local client configuration. [Plugin packaging](https://developers.openai.com/plugins/build/plugins) distinguishes repository marketplaces from workspace and universal directory publication. [Current OpenAI submission flow](https://developers.openai.com/plugins/deploy/submission) requires a verified publishing identity and portal access. Skills-only submissions do not require MCP review cases or a recording; adding MCP to an existing skills-only plugin is unsupported, so preserve separate package identities. No acceptance is implied. [ChatGPT custom MCP guidance](https://developers.openai.com/api/docs/guides/custom-mcp-server) describes remote/tunnel connection; a local stdio executable alone is insufficient. A hosted service would require a separate scope, hosting/security design and owner decisions. Do not expose it merely to market this release. [Claude Code](https://code.claude.com/docs/en/mcp), [VS Code](https://code.visualstudio.com/docs/agents/reference/mcp-configuration) and [Cursor](https://cursor.com/docs/mcp) are the configuration references. [MCP quickstart](MCP_QUICKSTART.md) contains exact snippets. Client approval and configuration remain local to the developer. # Technical registry readiness Reviewed 2026-10-08. Canonical install: `pip install implicit-ai`. Listings remain independent of package publication. | Candidate | Audience / authority | Submission, cost and requirements | Implicit decision | | --- | --- | --- | --- | | PyPI | Python developers; official package index | Existing stable package; free index, existing project ownership | LIVE 1.0.0 | | GitHub repository and topics | Developers; authoritative source | Project-owned metadata/source, existing authentication | LIVE | | Official MCP Registry | MCP clients; protocol-maintained metadata registry | Free metadata publication; namespace authentication and package ownership verification | PREPARED; PyPI prerequisite missing | | OpenAI Plugins Directory | ChatGPT/Codex users; official platform | Verified owner identity, portal access and review; new terms require owner acceptance | Separate skills-only package PREPARED; no acceptance claimed | | Awesome MCP Servers | Developers; maintained community source list | GitHub PR; public installable server, accurate categorized entry, maintainer review | SUBMITTED [PR #16015](https://github.com/punkpeye/awesome-mcp-servers/pull/16015); acceptance pending | | Smithery | MCP developers; third-party directory | Current publisher/account and hosting requirements must be verified in its portal | DEFERRED; published hosted connection is not available | | Zenodo | Research/software citations; archival repository | Owner login, license/identity/terms review and deposition | PREPARED recommendation; no DOI created | Sources: [official MCP publishing](https://modelcontextprotocol.io/registry/quickstart), [package ownership rules](https://modelcontextprotocol.io/registry/package-types), [OpenAI submission](https://developers.openai.com/plugins/deploy/submission), [community contribution rules](https://github.com/punkpeye/awesome-mcp-servers/blob/main/CONTRIBUTING.md), [citation/archive guidance](https://docs.github.com/en/repositories/archiving-a-github-repository/referencing-and-citing-content). ## Official MCP Registry prerequisite PyPI-based registration verifies the published package description contains `mcp-name: io.github.zeitcow/implicit-core`. The immutable published 1.0.0 README lacks that marker. Changing repository Markdown does not change PyPI's release description. Prepared [server manifest](../mcp/server.prepared.json) matches the current schema. Schema validation is not successful ownership verification or publication. Its package/console executable mapping must be confirmed in the publisher/client rehearsal; the supported local launch is `implicit-mcp`, while the package name is `implicit-ai`. Exact next steps for the next properly versioned package release, if the owner chooses registry publication: 1. Include `` in the package README. 2. Apply ordinary release/versioning verification; update both manifest versions to that release. Do not replace 1.0.0 artifacts or publish merely to decorate metadata. 3. Verify the marker in the live PyPI JSON description. 4. Install the official mcp-publisher CLI, validate the manifest and authenticate the zeitcow namespace through the current supported GitHub flow. 5. Confirm that the client launches `implicit-mcp` from `implicit-ai`, publish, and verify the returned registry record before labeling SUBMITTED/LIVE. MCPB or OCI packaging could provide another route but is not asserted to exist and is not a reason to expand frozen Core. ## Community submission Submitted for maintainer review in [PR #16015](https://github.com/punkpeye/awesome-mcp-servers/pull/16015). The entry accurately scopes the server to synthetic local state. Submission is not acceptance. Concise entry: `[zeitcow/implicit-core](https://github.com/zeitcow/implicit-core) - Python stdio MCP for bounded synthetic experience addressing, selective state materialization, provenance and fixed benchmark/adapter rehearsal. Real environment adapters use the SDK.` Place it in the relevant developer-tools category in alphabetical order, preserve the repository's entry conventions, disclose the limited synthetic scope in the PR, and wait for maintainer review. No paid placement, bulk submissions or endorsements are involved. # Citing Implicit Core 1.0.0 was released on 2026-10-08. Cite the software with [CITATION.cff](../CITATION.cff) and the immutable [v1.0.0 source](https://github.com/zeitcow/implicit-core/tree/v1.0.0). The stable source SHA is cac3e72e1f4958d1873d3a6d28d320131169324f. Suggested citation: Jean C. Martinez. Implicit: the experience layer for AI agents. Version 1.0.0, 2026-10-08. Apache-2.0. https://github.com/zeitcow/implicit-core/releases/tag/v1.0.0. Benchmark citations must separately identify **rc1**, its 155 comparable native ENV systems cases, the [sanitized numeric summary](../benchmarks/rc1-summary.json), and [methodology/limitations](../BENCHMARKS.md). The stable publication date is not asserted to be the original benchmark measurement date. The preserved public summary does not record that measurement date. The rc1 population preserved 155/155 equivalent state/tool/reward cases, with 93.88% aggregate, 94.40% mean and 99.55% median retained serialized/materialized-state reduction, and approximately +0.554 seconds/case mean full-pipeline latency overhead. Bytes are not RAM. Public users can verify arithmetic and run the separate toy; restricted native assets are not distributed. [GitHub's citation and archive guidance](https://docs.github.com/en/repositories/archiving-a-github-repository/referencing-and-citing-content) describes software citation and Zenodo archival integration. Archival DOI creation is prepared for the owner: sign into Zenodo, review its terms and ownership, connect only the public repository, select the existing stable release for archival, check author/version/license/benchmark scope, then approve deposition. No DOI or academic endorsement is claimed here. # Public adoption measurement Implicit has no hidden product telemetry. Measure public aggregate signals and voluntary integration evidence. The timestamped [baseline](../ADOPTION_BASELINE.md) and [machine-readable snapshot](../ADOPTION_METRICS.json) are observations, not counts of active users. Stars, forks and downloads cannot establish production adoption. Our own installation checks, automation and CI can affect downloads and traffic. Run the optional measurement tool from a public source checkout: ```console python tools/adoption_snapshot.py ``` It writes a new timestamped JSON file under `dist/adoption/`; existing snapshots are not overwritten. It fetches GitHub repository counts, release downloads, issue/PR totals, contributor counts and PyPIStats aggregates. It is separate from the SDK and CLI runtime. GitHub anonymous rate limits may apply. An optional GITHUB_TOKEN can provide project-owner API access; it is never recorded. `--owner-traffic` requests only aggregate views/clones over the API's rolling window. Keep that output private unless the owner chooses to publish it. No visitors, anonymous downloaders or personal identities are inferred. Unavailable metrics are null with an HTTP status/reason, not zero. Discussions, citations, backlinks, public mentions and search indexing need separate observations. Search indexing and retrieval readiness are independent. [Discovery guidance](../AI_DISCOVERABILITY.md). For follow-up, preserve weekly snapshots and compare the same windows, noting releases and our own verification activity. Count voluntary public adapter reports, external PRs and reproducible issue reports separately. Capture no private data and send no unsolicited follow-up. # Adoption baseline Observed 2026-10-08T22:09:36.209356+00:00. This is the first distribution baseline, not active users or production adoption. | Signal | Observed | | --- | ---: | | Stars | 0 | | Forks | 0 | | Watchers | 0 | | Issues (all) | 0 | | Pull requests (all) | 0 | | External non-bot commit contributors | 0 | | Discussions | 0 | Release asset downloads: [{"tag": "v1.0.0", "downloads": 27, "assets": [{"name": "checksums.txt", "downloads": 6}, {"name": "implicit-core-docs-1.0.0.zip", "downloads": 3}, {"name": "implicit-core-plugin-1.0.0.zip", "downloads": 3}, {"name": "implicit-core-public-source-1.0.0.zip", "downloads": 3}, {"name": "implicit_ai-1.0.0-py3-none-any.whl", "downloads": 6}, {"name": "implicit_ai-1.0.0.tar.gz", "downloads": 6}]}, {"tag": "v1.0.0rc2", "downloads": 21, "assets": [{"name": "checksums.txt", "downloads": 4}, {"name": "implicit-core-docs-1.0.0rc2.zip", "downloads": 3}, {"name": "implicit-core-plugin-1.0.0rc2.zip", "downloads": 3}, {"name": "implicit-core-public-source-1.0.0rc2.zip", "downloads": 3}, {"name": "implicit_ai-1.0.0rc2-py3-none-any.whl", "downloads": 4}, {"name": "implicit_ai-1.0.0rc2.tar.gz", "downloads": 4}]}] PyPIStats recent download observation: {"source": "https://pypistats.org/api/packages/implicit-ai/recent", "http_status": 404, "data": null, "reason": "Not Found"} GitHub views/clones are available only through owner access and are preserved privately. Search indexing, citations, backlinks, public mentions and active users are not measured by these counters; unavailable values are null, not zero. Our install checks and CI can contribute to download/traffic counters. No hidden telemetry or identification of anonymous users is used. [Machine-readable snapshot](ADOPTION_METRICS.json), [measurement method](docs/ADOPTION.md), [repeatable script](tools/adoption_snapshot.py). Install: `pip install implicit-ai`.