Open-Source Tool Frame: Using Markdown Files to Solve the AI Agent Context Loss Problem

As AI-assisted programming becomes increasingly mainstream, one recurring pain point continues to frustrate developers: every time you start a new session, you have to re-explain the entire project to the AI Agent from scratch. A developer on Reddit shared Frame, an open-source platform he spent eight months building, designed to tackle this problem at its root.

What Problem Does Frame Solve

According to the developer (GitHub user kaanozhan), Frame was initially built primarily with Claude and later switched to Codex. It targets several structural weaknesses that emerge when working with AI on long-term, large-scale projects.

The first pain point is repeatedly explaining the project. Every new session requires the developer to re-explain the project background, goals, and constraints from the beginning — inefficient and prone to gaps. The second is Agent scope creep — AI frequently modifies parts you never intended it to touch, with scope spiraling out of control. The third is more subtle: untraceable decisions. Months later, looking back at the code, you can see what changed but can no longer remember why. Finally, there's documentation drift — notes quietly fall out of sync with the actual codebase, eventually becoming worse than having no documentation at all.

Frame open-source platform overview

These issues barely matter for small toy projects, but once you're working on larger-scale engineering, they become a genuine burden. The author's view is straightforward: when dealing with large projects, this kind of "context engineering" is an unavoidable requirement.

Core Mechanism: Persisting Context as Files

Frame's design philosophy can be summed up in one sentence — let context live in files within the repository, not in a chat window that's already been closed.

From Paragraphs to Spec Files

The user inputs a natural language description, and Frame converts it into a structured spec file containing five explicit fields: problem, goal, constraints, success criteria, and out of scope.

The "out of scope" field is worth highlighting. Before any implementation begins, what shouldn't be done gets written down in black and white. This transforms project scope from a vague "feeling" into a clear statement you can point to at any time — which is precisely the key to reining in Agent scope creep.

Ask First, Then Plan

Before writing an execution plan, Frame surfaces all unresolved questions to the user. This upfront clarification step prevents AI from charging ahead and making assumptions when information is incomplete.

Record the Outcomes

After the work is done, Frame generates an outcome file documenting three things: what was originally planned, what actually happened, and which changes were rolled back. This record keeps the "why" together with the code itself.

Technical Design Highlights

Frame uses no wrapper layers and requires no manual copy-pasting. The key lies in leveraging the AGENTS.md mechanism — Codex automatically reads this file, so a brand-new session already "knows" the full project context before it begins.

Going further, when a new spec is created, the system first reads the existing specs and explicitly identifies which previous decision it supersedes. This means the evolution chain of decisions is fully preserved — the reasoning always travels with the work, rather than disappearing when a chat session closes.

To address documentation drift, Frame introduces a freshness check: it actively flags discrepancies when notes and the codebase diverge. The author admits this is the only way he found to catch drift in a timely manner.

All of this information is stored as plain Markdown files in your repository — readable, version-controllable, portable, with no proprietary format lock-in.

AGENTS.md is a convention supported by AI coding tools like OpenAI Codex. When placed in the root of a repository, Agents automatically read its contents at session startup, giving them project background knowledge, coding standards, and operational constraints — without the user having to manually paste anything. Similar mechanisms exist under different names in other tools: Cursor has .cursorrules, Claude Projects has system prompts, and so on. At their core, all of these approaches move "persistent instructions to the AI" from the conversation layer down to the file layer. By building on AGENTS.md, Frame's context management solution avoids dependency on any proprietary API or middleware — as long as the tool supports the convention, the entire mechanism works out of the box.

A Few Thoughts

Frame reflects an important trend emerging in the Agentic Development space: context management is evolving from a temporary conversational behavior into a persistent engineering practice. Codifying specs, decisions, and outcomes as files in the repository is fundamentally about building "institutional memory" for AI collaboration.

This thinking aligns with what a growing number of teams are doing — rather than relying on ever-longer context windows or complex retrieval systems, structure the critical information directly into the codebase so tools can read it natively. It's simple, transparent, and introduces no additional dependencies.

Of course, as an early-stage open-source project built by a solo developer over eight months, Frame is currently more of a methodology implementation than a mature product, and its robustness and ecosystem still await community validation. The author himself has stated clearly that the project was open-sourced specifically to gather contributions and feedback — which is exactly what it needs most. Interested developers can learn more through the GitHub repository at github.com/kaanozhan/Frame.

For developers who collaborate with AI Agents and are tormented by the "re-explain everything every session" problem, the file-centric context management paradigm that Frame offers is well worth trying.

Agentic Development refers to giving AI Agents the ability to autonomously plan, invoke tools, and execute multi-step tasks — rather than simply answering single questions. In this mode, Agents can read and write files, run code, call external APIs, and adjust their next steps based on intermediate results. This brings significant efficiency gains, but also introduces new risks: Agent action boundaries are hard to control, intermediate decisions are opaque, and once the context window closes, the entire reasoning process becomes difficult to reproduce. Frame targets precisely these systemic issues that Agentic workflows expose in long-cycle projects. Its "files as memory" approach is essentially building a stateful external memory infrastructure to supplement stateless AI sessions.