Anyone who has used AI tools for a while has probably run into this annoyance. You ask it to write a weekly report in the morning and it doesn't know your KPI framework was overhauled last week. You ask for a technical proposal in the afternoon and it has no idea you spent three months locking down your tech stack. Every new conversation means re-explaining the project background, which decisions were made and why.
In multi-person collaboration the problem scales up fast. Five people each interacting with AI separately; the AI's understanding of each person is isolated. A discusses an architecture decision with the AI, B has no idea that conversation happened. Five people are repeating the same explanations and none of them know the others already did.
Context Fragmentation Has Nothing to Do with Model Capability
Current mainstream AI tools store memory as conversation history stuffed into a context window. When the window fills up, older messages get truncated. That works fine for a single conversation but falls apart in cross-day, cross-week team collaboration. Even with 128K token support, cramming all project history in there causes information density to collapse and the model loses the ability to focus on what matters.
Team collaboration needs memory across several layers. Project background, tech stack choices, the reasons behind past pivots; this long-term context doesn't appear in any single conversation but affects every task. One team member prefers concise communication while another wants detailed reasoning; the AI should remember these differences instead of outputting the same format for everyone. Last week's design decision and why it went that way, how that choice affects this week's sprint planning; if the AI can't see these connections, its suggestions will clash with earlier direction.
Some products use vector retrieval to extend memory, storing past conversations as embeddings and recalling relevant snippets by semantic similarity when needed. This eases the length constraint but semantic similarity and causality are two different things. "This design decision was made because of a performance incident last quarter"; that kind of causal logic doesn't survive embedding encoding. What you need is a context system that understands event sequence, decision background, and technical evolution, not simple keyword matching.
This is a problem that needs architectural-level thinking. Octo takes an interesting approach: extracting context from individual conversations and turning it into shared team assets. Project background, historical decisions, discussion records stop being someone's private memory and become a shared resource accessible to everyone collaborating, both humans and agents. New team members or newly configured agents don't start from scratch; the system's built-in context already contains the key information about how the project evolved. This turns context from a burden you re-enter every conversation into infrastructure the system provides out of the box.
Tacit Knowledge Is the Hard Part
Explicit knowledge is straightforward; write it into documentation and feed it to the system. But the information that actually affects output quality in team collaboration usually isn't in any document. The specific reason a technical approach was rejected, the writing style your boss prefers for certain documents, a particular client's communication taboos. This information only lives in people's heads and current AI tools have no mechanism to capture it.
When you tell the AI in a conversation that something is too verbose or the conclusion should come first, you're transmitting preferences. But that feedback vanishes when the conversation ends. Next time it still generates verbose output with conclusions at the end.
When multiple people collaborate with the same AI system simultaneously, preferences can contradict each other. The product manager wants output leaning toward business analysis, the engineer wants a technical implementation perspective. If the system can't distinguish between different people's preferences, it produces a compromised version that satisfies nobody.
Octo has a clever design for this: automatically distilling user feedback like acceptances, rejections, and annotations into persistent preferences that agents reference when taking on new tasks. Tacit knowledge capture shifts from manual documentation to automatic system learning. You don't need to write a document explaining your preferred style; the system learns from your feedback behavior. The longer you use it, the more preferences accumulate, and the deeper the agent's understanding of your work becomes. This kind of accumulation doesn't come from model capability but from real feedback during actual use.
Adding Memory to AI Is Harder Than It Looks
Adding memory isn't just plugging in a database. You need a persistent storage layer for long-term context and preference material. You need a retrieval and injection mechanism to manage context budget, deciding which memories to recall before each conversation and in what priority order. You need a feedback loop that automatically converts user acceptances and rejections into preference material. As memory volume grows, retrieval latency increases and noise information leaks into context, actually degrading output quality.
The difficulty lies in retrieval precision and automatic preference distillation, not in storage.
Cross-Task Dependencies Are Easy to Overlook
Last week's architecture review conclusions, this month's technical debt cleanup plan, next quarter's product roadmap; these seemingly unrelated pieces of information actually influence each other. If the AI can only see the current conversation and not these cross-task dependencies, its suggestions tend to be isolated and short-sighted.
Octo's Loop design attempts to address this: each task isn't a standalone ticket but an execution unit with upstream and downstream dependencies. The system tracks relationships between tasks so agents automatically reference relevant historical decisions and context when picking up new work.
This field is still early but the direction is clear. Memory isn't a bolt-on feature; it should grow inside the workflow itself. Every collaboration, every acceptance, every piece of feedback naturally becomes a system asset. Octo is building along this line of thinking, designing human-AI collaboration as a complete workspace where agents participate with identity and accumulated preferences, project context is shared across the team, preferences are automatically distilled through feedback, and tasks are linked through Loops into causal execution chains.
Octo is now fully open source on GitHub, with server, web/desktop client, iOS, Android, and CLI codebases, under Apache 2.0. If you're dealing with the same problems; AI tools that need fresh context every conversation, feedback that disappears, preferences that don't persist; pull the code and try it out. Deployment docs are in the octo-deployment repo with K8s manifests ready to go. The community is just getting started; if this direction seems valuable, drop a star and your early feedback will directly shape where the product goes.
Top comments (0)