Adaptive Context Engineering for AI agents

New project or existing codebase?

Starting something new

Give your agent a first build request. Keep planning light while the requirements take shape.

Start from a request, not a full specification
Answer the choices that matter as the agent asks
Review what it builds, then keep useful outcomes for the next task

Read the guide →Try the demo →

Joining an existing codebase

Ask how the tests run, then try a small change. Point the agent to the reasons behind the code.

Link to the docs you already have instead of moving them
Keep the reasons behind important choices from now on
Add a rule when a mistake repeats, not in advance

Read the guide →Try the demo →

What you get

Full Core supplies the files shown here, including four supporting CLI guides opened when needed. Essentials installs fewer categories, and Custom follows your selection. Apart from Memory's state entrypoints and the open-forge-cli Skill and guides, every category ships empty. The content comes from your work, or from Extensions you choose: a correction you keep repeating, a decision you don't want to explain again, a workflow worth reusing.

19: Markdown files in Full Core
0: runtimes or databases to run

Estimate your setup with open-forge status. The estimate covers tag-selected context. Required reads can add to it.

Grow your own framework →

What you get
AGENTS.md                     <- read the loader first
CLAUDE.md                     <- bridge for CLAUDE.md tools
.agents/
  loader.md                   <- loading and routing rules
  directives/_directives.md   <- required behavior
  guidance/_guidance.md       <- advice for recurring choices
  patterns/_patterns.md       <- reusable shapes
  skills/_skills.md           <- native SKILL.md capabilities
  skills/open-forge-cli/
    SKILL.md                  <- how to use the CLI
    references/               <- opened when needed
      discovery.md
      routes.md
      packages.md
      common.md
  templates/_templates.md     <- copy-ready starting files
  maps/_maps.md               <- pointers to important sources
  memory/                     <- working, emerging,
                                 crystallized, archived

How it fits together

Core gives the agent rules and links to the context its task needs. Memory keeps useful outcomes for later, separating temporary notes, unconfirmed findings, accepted knowledge, and history. Startup reads the loader, the installed folder indexes tagged to load, and the files their tags or rules require.

Show how the files fit together

At startup your agent reads its instructions, most main folder indexes, and the files their tags or rules require. Everything else opens when a task needs it.

Startup reads your agent instructions, the loader, installed entrypoints tagged to load, and required files such as the CLI usage Skill. Your setup determines the footprint.

AGENTS.md or CLAUDE.mdYour agent tool reads it automatically. It points to the loader.

.agents/loader.mdRead next, in full: the loading rules and the main folders.

An entrypoint is a folder's index file: its purpose, its rules, and one line per entry. Linked files open when selected, tagged to load, or required by a loaded rule.

Core How to work

DirectivesRules that must be followedEntrypoint at startup
Root rules: at startupScoped rules: when their scope is selectedFor example: run the tests before calling work done.
GuidanceAdvice for choices that keep coming upEntrypoint at startup
Linked files: when selected or requiredFor example: when to split a module.Extensions add Adaptive Collaboration.
PatternsReusable shapes that make work easy to create and checkEntrypoint at startup
Linked files: when selected or requiredFor example: the shape of an API error.Extensions add Work Records.
SkillsCapabilities packaged as SKILL.mdEntrypoint at startup
CLI usage Skill: required at startupOther Skills: when selectedFor example: a code review Skill.Starts with open-forge-cli. Extensions add use-workflow.
TemplatesStarter files to copy and adaptEntrypoint on demand
Linked files: when selected or requiredFor example: a Decision starter.Most Extensions add starters.
MapsPointers to important sourcesEntrypoint at startup
Linked files: when selected or requiredFor example: your ADRs, wiki, or API docs.

Memory What to remember

Entrypoint at startup

These are places to keep material, not required steps. A record can start in any state that fits it. Accepted knowledge can go straight to Crystallized.

Working NowTemporary state for work in progress.Entrypoint at startup
Linked files: when selected or requiredExtensions add Checkpoints and Handoffs.
Emerging MaybeUseful material nobody has accepted yet.Entrypoint at startupAlso re-read at refresh points.
Linked files: when selected or requiredExtensions add Ideas, Analysis, and Observations.
Crystallized True nowAccepted knowledge that stays current.Entrypoint at startup
Linked files: when selected or requiredExtensions add Decisions and Documents.
Archived HistoryKept for reference. It no longer governs current work.Entrypoint on demand
Linked files: when selected or required

Possible moves: Working to Emerging when worth keeping but not settled. Emerging to Crystallized when accepted. Crystallized to Archived when replaced. Memory rules.

Read the startup files
Open what the task needs
Do the work
Save what's worth keeping

How loading works

Linked files open when selected or required. #LoadNow reads a file when its parent index loads. #KeepInMind also re-reads it at task start or resume, after a context restore, and before handoff or closeout while its scope is active. Both tags act through a loaded parent. The Skills rules explicitly require the CLI usage guide at startup.

A file with applyTo patterns applies only while the task works on a matching file.

open-forge context skills/open-forge-cli batches the default loading-tag closure and the required CLI guide. Extensions are optional packages you add.

Read the concepts →

Routes, not bulk context

A loader and one short entrypoint per folder. The entrypoints point the agent to the routes a task needs, and the rest stays closed.

How routing works →

Plain Markdown you own

No hidden database, no agent runtime, nothing tied to one vendor. Read it, diff it, and version it with the rest of your project.

Make it yours →

Grows without bloating context

Frontend rules live in a frontend scope, database rules in a database scope. A scope loads only when a task selects it, so new knowledge doesn't add to every task.

Scopes →