Z1P. Explore the core

Codebase context for people & AI

Less explaining.
More building.

Your AI can write code.
Give it the context it's missing.

Z1P maps code, dependencies and project docs into source-linked evidence your AI tools can retrieve. Pick up the work without explaining the codebase from scratch.

Try the free core See how context connects

Runs locally. MIT licensed. No account required.

⌁ checkout / context mapIllustrative example
One change. Connected context.

What depends on checkout.ts?

Follow the connection. Check the source.

Files, relationships and the evidence behind them.

Local extractionNo model needed to scan
01 Your code stays local by default02 Context comes with its source03 You choose what gets shared

A head start on the hard part

The code is there.
The context is scattered.

The import is in one file. The reason is in a document. The dependency sits in another repo. Z1P gives you a way to follow those connections.

01 / MAP

Start with your repo.

Scan local code and package dependencies. Explicitly include other repositories and Markdown docs when the work crosses boundaries.

Local, deterministic extraction
02 / CONNECT

Keep the evidence.

Preserve where a record came from and how a relationship was extracted. Follow the path back to the source before trusting a conclusion.

Inspectable records and relationships
03 / RETRIEVE

Give your agent a route in.

Use the CLI or Model Context Protocol (MCP) to retrieve relevant records within explicit limits, then read the source needed for the task.

Works without a model subscription

Follow the evidence

A graph should answer
“where do I look next?”

Choose a question to explore a small, illustrative checkout project. This is an interactive explanation, not a live scan or a hosted product preview.

YOUR NEXT CHANGE
CONTEXT TRAILExample data

Start with checkout. Follow its connections.

  1. TS
    cart.tsImports checkout. Inspect the caller.
    imports
  2. TS
    payments.tsCalled by checkout. Inspect the payment boundary.
    calls
  3. TS
    checkout.test.tsImports checkout. Review the existing assertions.
    imports

A connection tells you where to investigate. It doesn't prove a change is safe or that a test covers the behaviour.

Useful context. Clear boundaries.

Your repo.
Your tools.
Your call.

Read the open-core commitment

Bring the tools you already use.

The local CLI and MCP adapter expose retrieval and graph navigation. Your client supplies the AI. Z1P Core doesn't require a particular model provider.

Start without uploading your code.

Core scans run locally without executing the repository or calling a model. Sharing requires an explicit destination. The core has no telemetry.

Inspect what you're relying on.

Formats, extraction and verification are open source. Signatures identify assertions; they don't make them true. Limits and uncertain relationships stay visible.

For the “we should try this” conversation

Make the case
with your own repo.

Pick a task your team knows is awkward. Use the free core to find the relevant files and connections. Check the result against the source, then decide whether it helps.

Get the team evaluation brief
A USEFUL FIRST EVALUATION
  1. 01
    One real change

    Choose a bug, unfamiliar module or dependency update.

  2. 02
    A result you can check

    Did you find the required sources? What was missed?

  3. 03
    A reason to keep using it

    Compare investigation time and context used with your usual workflow.

Start free. Build the case for your team.

Free foundations.
Shared ambition.

The local core is available today. We're building the hosted platform for teams that want the graph maintained for them.

Available now

Z1P Core

Free / MIT licensed

For developers who want local control and an inspectable foundation.

  • Local repository and source scans
  • Bounded retrieval and graph navigation
  • CLI and MCP adapter
  • Signed, encrypted collections
  • No account or subscription required
Start with the core
In development

Z1P for teams

Let's shape it/ pricing to be announced

Planned: shared context that keeps up with the work.

  • Connected private repositories
  • Automatic graph refresh
  • Hosted private MCP access
  • Source-linked pull-request impact
  • Team access and administration
Discuss a team pilot

Opens a public GitHub issue. Please don't include private code or company information. No hosted service is available to buy yet.

From curious to hands-on

Try it on something
you actually work on.

Build the current tools from the public source, then run a bounded scan. It outputs evidence records for inspection. Signed collections and MCP setup are covered in the guide.

The current scanner release isn't on npm yet. This source-build route includes it.

Read the setup guide
TerminalGit + Node.js 24+

# Build the current core from source

git clone https://github.com/forgesworn/context.git z1p-core
cd z1p-core
npm ci --ignore-scripts
npm run build

# Replace the path with your JS / TS project 

node packages/context-tools/bin/encrypted-context.mjs scan-source /path/to/your-project

Before you start

Fair questions.

Is this another AI coding assistant?

No. Z1P Core provides codebase evidence and graph navigation through local tools. Your existing AI client can use its MCP adapter to retrieve context. It doesn't generate or change your code.

Which languages can it scan?

TypeScript and JavaScript use compiler-based extraction. Python, Rust, Go, Java, Kotlin, Swift, C, C++, C#, Ruby and PHP have more conservative lexical navigation. These levels are not equivalent: dynamic behaviour and ambiguous relationships may be omitted. See the scanner documentation for the exact limits.

Does my source code leave my machine?

Local core scans don't upload your code or contact a model. You control explicit uploads and sharing. If you connect an AI client, the evidence it retrieves may be sent to that client's provider under your configuration. Hosted platform data handling will be documented before launch.

Will it reduce our AI bill?

Retrieving selected evidence can reduce the context you send compared with sending a whole repository. The saving depends on your task and workflow. Our reproducible benchmarks separate source navigation from the evidence needed to answer. We don't promise a percentage reduction in your bill.

Can we buy the team version today?

Not yet. The hosted team platform is in development, and pricing hasn't been announced. You can evaluate the free core now and discuss what would make a team pilot worth paying for.

Will the free version stop being useful?

The published core is MIT licensed and works without our hosted service. The commercial plan is to charge for continuous operation and team workflows. Read the open-core boundary for the commitment and compatibility policy.

Spend less time reconstructing the picture.

Start your next change
with a little more context.

Explore Z1P Core