OKF for OpenCode — Using Knowledge Bundles with OpenCode

What Is Open Knowledge Format (OKF)?

Open Knowledge Format (OKF) is an open standard for packaging knowledge so that AI agents can load it reliably. An OKF bundle is just a directory of markdown files with an index.md manifest, YAML frontmatter on every document, and cross-links between concept files. Because it uses plain files, a bundle is portable: the same directory can be consumed by Claude Code, Cursor, Codex, and OpenCode without conversion. If you are new to the format, read What Is an OKF Skill? first.

A well-formed bundle looks like this:

```
my-bundle/
├── index.md                # Bundle manifest (required)
├── concepts/               # Core domain knowledge
│   ├── architecture.md
│   └── patterns.md
├── guides/                 # How-to guides
└── references/             # Reference documentation
```

OKF was designed to be agent-agnostic. Instead of locking knowledge into a single vendor's proprietary skill format, OKF keeps it in version-controllable markdown that any agent can read. That portability is exactly what makes it a great fit for OpenCode, which prides itself on being open and model-agnostic. For the broader picture, see our OKF for Claude Code and OKF for Cursor guides.

Why OpenCode Users Need Knowledge Bundles

OpenCode is an open-source AI coding agent that runs on the command line and in your editor. It connects to the model of your choice, reads your repository, and can plan and write code with you. But a coding agent is only as good as the context it can see. By default, OpenCode is limited to what is in your current project plus whatever the model already knows. That leaves a gap: the conventions, domain expertise, and architectural decisions that live outside the repository.

Knowledge bundles fill that gap. Instead of re-typing your team's coding standards, API conventions, or domain reference material into every conversation, you load an OKF bundle once and OpenCode can reference it throughout the session. This gives you:

• Consistent conventions — linting rules, commit style, branching strategy, and naming patterns that the agent follows every time
• Domain expertise — specialized knowledge about your stack that the base model may not have memorized reliably
• Project memory — architecture docs, decision records, and setup instructions that persist beyond a single prompt

How Persistent Memory Works in OpenCode

OpenCode supports several ways to keep knowledge available across sessions. Two of the most relevant for OKF are contributed memory and persistent memory.

Contributed Memory

Contributed memory is knowledge that you provide to OpenCode ahead of time — files, directories, or notes that the agent loads when it starts. This is the natural home for an OKF bundle. You tell OpenCode which directories to treat as source material, and it reads them into context so they are available without being re-added each time.

Persistent Memory

Persistent memory is knowledge that OpenCode writes down during a session — decisions, learnings, and facts it captures so they survive into future sessions. Where contributed memory is the input side, persistent memory is the output side. An OKF bundle slots in on the input side: it is your curated, version-controlled knowledge that OpenCode loads, while persistent memory keeps growing as you work.

Because OpenCode is open source, you can also point it at a directory of bundle files directly. The important idea is that OKF gives you a clean, portable way to feed curated knowledge into OpenCode's memory system without relying on an opaque, proprietary store.

How to Load an OKF Bundle in OpenCode

Step 1: Find an OKF Bundle

Browse the BundleDex directory and look for bundles tagged opencode or bundles that mention OpenCode in their description. The curated list at the bottom of this guide is a great starting point. You can also use the BundleDex search API to filter by the opencode tag.

Step 2: Clone the Bundle

Clone the bundle's GitHub repository into a dedicated directory so all your bundles live in one place:

```
mkdir -p ~/okf-bundles
git clone https://github.com/psinetron/echoes-vault-opencode.git ~/okf-bundles/echoes-vault
git clone https://github.com/iwe-org/iwe.git ~/okf-bundles/iwe
```

Step 3: Load the Bundle in OpenCode

Start OpenCode with the bundle directory available, and you can reference its content during the session:

```
# OpenCode reads the bundle directory for context
opencode --load ~/okf-bundles/echoes-vault

# Or reference knowledge during a session
# "Read ~/okf-bundles/iwe/index.md and follow the conventions in it"
```

Step 4: Add the Bundle to Persistent Memory (Optional)

For bundles you use constantly, add them to OpenCode's startup configuration so they load automatically on every session. The exact path depends on your OpenCode setup, but the pattern is to register the bundle directory as contributed memory in your config file:

```
# Example: register a bundle in your OpenCode config
# memory:
#   contributed:
#     - ~/okf-bundles/iwe
#     - ~/okf-bundles/echoes-vault
```

Step 5: Use the Bundle

Once loaded, ask OpenCode to follow the bundle's conventions, answer questions from its reference material, or apply its patterns to the code you are writing. Because the bundle is in plain markdown, OpenCode can read it the same way it reads your repo — no proprietary import required.

OKF vs OpenCode's Native Memory

OpenCode has its own memory concepts, but OKF is complementary rather than competing. Here is how they line up:

In practice you want both. Use OKF bundles for the knowledge you curate and share — conventions, domain reference, architecture — and OpenCode's persistent memory for the facts it picks up while working. An OKF bundle can even be loaded into contributed memory, effectively turning curated knowledge into part of OpenCode's native memory layer.

Best OKF Bundles for OpenCode

These bundles are tagged for OpenCode or mention it in their description, ranked by community adoption (GitHub stars):

Browse all 583 bundles on BundleDex, or filter by the opencode tag to find more.

FAQ