Ornith-1.0 agent memory is not a feature hidden inside the model. Ornith-1.0 can run locally, use tools, and accept long context, but reusable repository knowledge still has to live in an external layer that survives individual prompts and sessions.
Why Local Coding Models Need Memory
DeepReinforce presents Ornith-1.0 as an open-source model family for agentic coding. Its official materials document reasoning, tool calling, OpenAI-compatible serving, and local or self-hosted paths through Ollama, llama.cpp, Transformers, vLLM, and SGLang. Those capabilities make it possible to put an open model behind a coding agent such as OpenCode.
They do not give that model persistent knowledge of your repository.
A context window is working space. It contains the current instructions, selected files, tool results, and conversation history until those inputs are removed or compacted. Agent memory is different: it preserves useful project knowledge so a later task, session, or model can recover it without reconstructing everything from raw files.
This distinction matters more in local workflows because the operator owns the full stack. A hosted coding product may bundle retrieval and repository indexing. An Ollama-backed workflow gives you more control, but it also makes you responsible for:
- selecting relevant files;
- maintaining project instructions;
- refreshing architectural knowledge;
- deciding what should persist;
- preventing stale or sensitive material from becoming trusted context.
Ornith's official Ollama page currently lists 9B and 35B variants, while the canonical repository also documents larger serving configurations. Model size changes latency and hardware requirements. It does not remove the need for a memory policy.
The Repo Understanding Problem
Repository understanding is not the same as reading many files. The useful result is a defensible model of how code, configuration, tests, documentation, and ownership boundaries relate.
Consider a request to change authentication behavior. A coding agent may need to identify:
- the public request handler;
- shared authorization middleware;
- generated client types;
- database policies;
- integration tests;
- an architecture decision explaining why one route is intentionally different.
A raw search can find each item. It does not automatically show which path is authoritative or why the boundary exists. Long context can hold more search results, but low-value text still competes with the evidence needed for the change.
Ornith's reported benchmark results suggest that its models can operate inside agentic coding harnesses. Those figures are vendor-reported, however, and they do not establish performance on a particular repository. A team trial should therefore test repository navigation separately from code generation.
One practical test is to ask the agent to explain the relevant system path before it edits anything. Require it to name the files, symbols, relationships, and uncertainty behind its plan. If it cannot explain why those sources matter, adding more context may only make the unsupported answer longer.
Measure that trial across fresh sessions, not only one carefully prepared conversation. Track orientation time, files opened before the first useful answer, unsupported claims, repeated searches, and corrections after tests. Those observations reveal whether the workflow has reusable repository memory or merely a large temporary prompt.
Where Repeated File Reading Wastes Context
Repeated reading becomes wasteful when every session performs the same orientation work.
A new coding-agent session often starts by reading the README, package manifests, directory tree, configuration files, and several plausible implementation files. That discovery is necessary once. Repeating it for every bug, feature, and reviewer question turns repository orientation into a permanent token and latency tax.
The waste usually appears in four places:
- Stable architecture is rediscovered. Package boundaries and central modules rarely change every hour, yet agents repeatedly infer them.
- Tool output overwhelms the task. Large grep results and file dumps consume context before the agent reaches the relevant code.
- Sessions disagree. Two agents can build different mental models from different search paths.
- Compaction removes detail. A long session may summarize earlier discoveries, forcing the agent to search again when it needs exact evidence.
Some rereading is healthy. Source code remains the authority, and current files must be checked before an edit. The goal is not to stop reading code. It is to avoid rebuilding the entire map when only a few current paths need confirmation.
A shared project-memory layer narrows retrieval, while current source files remain the final authority.
How Knowledge Graphs Support Agent Memory
A code knowledge graph can act as structured repository memory by storing entities and typed relationships rather than a flat transcript of previous prompts.
Useful nodes may represent files, packages, functions, classes, tests, schemas, routes, and architecture documents. Edges can record imports, calls, ownership, coverage, generation, or documentation relationships. The graph then becomes a query layer: an agent can ask which modules depend on a symbol, which tests cover a route, or which document explains a boundary before opening the underlying files.
Graphify follows this model. It creates queryable repository artifacts and provides commands for graph queries, paths, explanations, updates, and watch workflows. The existing Ornith-1.0 and code knowledge graph guide explains the model-versus-repository-visibility distinction. The memory layer adds a further operational question: what knowledge should persist, and how is it refreshed?
A sensible memory policy separates four classes:
| Memory class | Examples | Refresh rule |
|---|---|---|
| Stable instructions | Build commands, generated-file rules, review requirements | Review when workflow changes |
| Structural knowledge | Imports, symbol relationships, package communities | Rebuild after structural changes |
| Decision context | ADRs, rationale, ownership boundaries | Update when a decision is superseded |
| Task history | Failed approaches, temporary observations | Retain selectively with expiry |
This structure is model-independent. An Ornith endpoint, another local model, and a cloud model can reuse the same graph through files, CLI queries, a local API, or MCP. Each agent should still verify the current source before changing it.
Limits for Local Workflows
Local does not automatically mean private, correct, cheap, or production-ready.
First, verify the actual runtime path. Ollama's ornith:9b and ornith:35b entries make local evaluation convenient, but listed artifact size is not total RAM or VRAM use. Context length, quantization, concurrency, and tool traces affect resource requirements.
Second, verify tool behavior. Ornith's official recipes document reasoning and tool-call parsers. A model served behind an OpenAI-compatible endpoint can be configured in OpenCode, but transport compatibility does not prove reliable multi-step tool use.
Third, keep memory fresh. A stale graph can be more dangerous than no graph because it looks authoritative. Graph updates should follow merges that change imports, routes, schemas, generated code, package boundaries, or architecture documentation. Graphify's CLI reference documents update, watch, and Git-hook options.
Finally, govern access. Do not put secrets, production credentials, private customer data, or unrestricted historical transcripts into shared memory. Record provenance and update time so the agent can distinguish current source-derived facts from human notes and inference.
FAQ
What memory should stay outside the prompt?
Keep reusable structure, stable workflow rules, architecture decisions, provenance, and refresh metadata outside the prompt. Load only the portion relevant to the current task. Current source code and exact test output should still be read when needed.
How should teams refresh repo memory?
Use repository events rather than an arbitrary calendar. Rebuild structural memory after merged changes to dependencies, routes, schemas, package boundaries, generated artifacts, or architecture documents. Store the source commit and generation time with the memory artifact.
Can multiple local models reuse one memory layer?
Yes. A model-independent graph or repository report can be exposed through a CLI, files, local API, or MCP. Different models can query the same layer, but each run should record the model, task, retrieved evidence, and source revision for comparison.
Conclusion
Ornith-1.0 makes local agentic coding easier to evaluate, but a capable local model is only one layer of the system. Long context supports temporary working memory; it does not create durable repository understanding.
Use the model for reasoning and tool use, the agent for permissions and execution, and a maintained project-knowledge layer for reusable structure. The decision rule is simple: if every new session has to rediscover the same architecture before useful work begins, move that stable map outside the prompt—and keep it tied to current source.