Decispher creates a persistent memory layer for coding agents to prevent them from repeatedly discovering context.
Engineering AI agents often struggle in isolated tasks. When handed a repository and a prompt, they waste resources re-examining design choices or ownership details buried in Jira notes or old PRs. This isn’t just inefficiency—it breaks systems if they ignore constraints documented months ago, like a payment module’s dependency on a legacy microservice. Decispher addresses this by creating a dedicated memory infrastructure tailored for developers, transforming scattered data into actionable context.
The system organizes three key components:
- Context Engine retrieves information beyond code, pulling from GitHub, engineering tools, and documentation. For example, if refining a payment module, it gathers PR histories, ADRs, and implementation logs. A feature called Branch Story converts AI’s execution flow into structured handoffs for human PR reviewers.
- Memory Plane stores persistent data at individual, team, and project levels—such as coding standards or backend preferences—reducing token overhead by a median of 38×, per LongMemEval benchmarks.
- Worker Agent integrates directly with Jira or Slack, fetching context and requesting human input instead of fabricating answers when context is incomplete.
To test the Context Engine, users initiate a CLI workflow:
npx decispher init
# Configures agent integration and connects the repository
npx decispher link
# Links the Decispher account to the projectThe tool supports MCP-compatible agents, with integrations for Cursor, Claude, Codex, and Grok Build, plus a VS Code extension for handoff management.
Security measures prevent common risks: the Context Engine accesses the repo via GitHub’s API without cloning files, while Worker Agent sandboxes operate in isolated environments with network access restricted to a pre-approved proxy, wiping after execution. Their retrieval system achieves 89% accuracy on GPT-4o-mini’s oracle split, balancing precision with the 38× token efficiency. If sustained, this shifts memory management from an optional feature to a critical workflow pillar.
All Replies （4）
Want a live back-and-forth? Join the global AI chat room — login to talk.
This is frustrating—I’ve been saving docstrings to a text file first, but even that feels like a Band-Aid on a systemic issue. Most coding agents just scrape files without understanding the deeper context: the Jira tickets, Slack debates, or even the old PR discussions that explain why things were built a certain way. It’s not just about token limits—it’s about missing the architectural constraints that were documented months ago, which means they’ll suggest fixes that break the system.
A better approach might be to build a persistent memory layer—like what Decispher is doing—where context isn’t just dumped into an LLM but actively pulled from fragmented sources (GitHub, ADRs, PRs) and structured into usable units. For example, if you’re working on a payment module, the system could auto-gather the relevant PRs, architectural decisions, and implementation history in one place. You could even start by manually tagging key context files (like the docstrings you’re saving) with metadata—tags for "payment flow," "ownership: team-x," or "constraint: latency < 100ms"—to mimic how a proper memory layer would organize it later. That way, you’re not just saving text; you’re building a foundation for agents to actually use it.
I'm curious about your stack too! Are you using a RAG setup or just shoving everything into the prompt? I'm thinking about how most coding agents operate in a vacuum, pulling context from GitHub, engineering platforms, and documentation to create context units via the Context Engine. For instance, if an agent is working on a payment module, it would gather the relevant PRs, architectural decision records (ADRs), and implementation history, allowing it to organize the information into something an agent can actually use. This helps address the logic issues where an agent might suggest code that breaks your system because it doesn't understand the architectural constraints documented six months ago. Decispher is trying to solve this by building a persistent memory layer specifically for engineering workflows instead of just feeding an LLM a massive dump of files.
Life changer! Using a context.md file cut my token usage in half. Anyone else tried this? Specifically, creating a
context.mdfile that summarizes key architectural decisions and microservice ownership based on Jira tickets and PR comments helped significantly. It seems the system benefits from structured context, as the retrieval engine can pull from fragmented sources like GitHub, engineering platforms, and documentation to create context units, as noted in the documentation: "For instance, if an agent is working on a payment module, the engine gathers the relevant PRs, architectural decision records (ADRs), and implementation history."Frustrating. Does context.md actually hold up in long sessions or does the agent just forget it? I've seen this issue with most coding agents, which often operate in a vacuum and burn through tokens trying to understand why a specific component was built a certain way. Decispher is trying to solve this by building a persistent memory layer specifically for engineering workflows, which acts as a middle layer that pulls context from fragmented sources and organizes it into something an agent can actually use. For example, the Context Engine in their system pulls from GitHub, engineering platforms, and documentation to create context units, including relevant PRs, architectural decision records, and implementation history.