Zeeq Introduction

Zeeq originated from observing the broad range of prompting styles and approaches used by developers across an organization. It came to feel like a "wild west" of agent coding with wildly variant outcomes while using the same "robot".

This variance in skill level, experience, prompting style ultimately projects into agent generated code.

How can organizations achieve more consistent, high quality results across an engineering team?

Zeeq aims to narrow the gap between individual developers in an organization using agentic coding by providing canonical, baseline documentation on the best patterns and practices for the organization's codebase irrespective of the agent harness the developer is using.

Ultimately, with enough curated, canonical guidance, any contributor can produce high quality code that aligns with organizational best practices -- even without an engineering background.

This focus drives much of the design of Zeeq and the technical design decisions.

Why MCP?

Unlike local skills and tools, Zeeq chooses to use MCP as this provides teams several benefits like telemetry while simplifying the problem of distribution and keeping content up-to-date.

Here is a conceptual mapping:

Conceptual Design

Zeeq is designed to aggregate and index multiple sources of documentation into a single, canonical, universal knowledge base that can be accessed by agents via MCP.

This knowledge base includes not only documents, but also team-wide memories that are both used to power code reviews. Zeeq closes the loop: you give it the best practices and how you want the code to be written, agents use that to write code, Zeeq code reviewers ensure that the guidance and tools were used.

Key Benefits

• Universal knowledge base: Aggregate and serve multiple knowledge bases from one MCP server with content from GitHub repositories and internally managed docs.
• Enterprise ready: Start every project with a consistent set of guidelines and best practices already in place (versus writing new docs for each project in your org).
• Ideal for microservices: Centralizes knowledge so every repository can gain knowledge about other services and how to use them correctly.
• Knowledge composition: Combine documentation from multiple sources into a single, canonical knowledge base. Include generic org-level best practices with project-specific guidelines.
• Increased consistency: Different agents use different heuristics for selecting and processing contents in files. By pre-processing the files provides more consistent retrieval of information.
• Increased token efficiency: Using full-text search, semantic search, and other retrieval techniques available during pre-processing, Zeeq can reduce the amount of tokens needed to find the correct, canonical information.
• Decreased tool usage: Zeeq reduces tool usage searching files by using keyword expansion during search and matching relevant topics using full text and semantic search to provide accurate results.
• Higher quality: Because the knowledge base is curated and contains only canonical information, agents always get best practices leading to higher quality output.
• Cross linking: Zeeq's simple retrieval mechanism allows for easy cross-linking of related information, enhancing the depth of knowledge available to agents and providing it in efficient payloads.
• Centralized Telemetry: Zeeq provides visibility into tool usage because it exposes prompts, resources, and tools in a central server-backed API that emits OpenTelemetry logs, traces, and metrics.
• Closed loop: Zeeq serves canonical documents to coding agents, stores memories of corrections, and then uses these to run code reviews, closing the loop and ensuring high quality code reviews that match your org standards.

✅ Objectives

Key objectives that drive Zeeq's design:

Low Friction for Adoption

Zeeq is designed to be easy to set up and integrate into existing workflows with minimal changes required. By leveraging MCP, Zeeq can be integrated with a wide range of coding agents without requiring significant changes to the agent or developer workflow.

Git submodules, for example, are another way to share documentation across multiple repositories, but they come with significant friction in terms of setup and maintenance. Zeeq aims to provide a low-friction alternative that is easy to set up and maintain.

Decouple Documentation from Code

While placing documentation alongside code can be beneficial, it also comes with challenges since documents typically have different lifecycles and workflows compared to code (e.g. you may not want to run CI on doc only changes). You may want to have different teams that own and approve documentation and different review processes.

Keeping large bodies of documentation in the code can also lead to reduced agent performance while increasing inference costs.

In some cases, you may have documentation that should be used in every repository (e.g. security guidelines) that would be cumbersome to duplicate across every repo. Zeeq allows decoupling documentation from code while still making it easily accessible to coding agents.

If your system is comprised of many microservices, then Zeeq can help centralize knowledge so every service can understand how to properly interact with other services.

Zeeq reduces the need to copy and sync documentation across multiple repositories by providing a remote centralized knowledge base that can be shared across multiple codebases.

Support Multiple Agents and Workflows

Zeeq is designed to be agnostic to the specific coding agents or workflows used by developers. Different developers vibe with different agents; Zeeq ensures that no matter what agent a developer uses, the agent can access the same high-quality, canonical guidance.

Zeeq is unopinionated about workflows; it only provides canonical knowledge.

Advanced Indexing and Retrieval

By moving indexing to a database-backed server, it is possible to leverage advanced indexing and retrieval techniques (e.g. vector and graph search) that may not be feasible in a local agent context due to resource constraints and the development environment.

Observability and Analytics

By centralizing the knowledge base, Zeeq can provide insights into how documentation is used, which documents are most frequently accessed, and where gaps in documentation may exist via OpenTelemetry traces, logs, and metrics.

This enables teams to continuously improve their documentation based on real usage patterns.

Composable Knowledge Sources

Zeeq allows arbitrary GitHub repositories to be connected as knowledge bases. This allows teams to compose knowledge bases from multiple sources, including org-level best practices, project-specific guidelines, and third-party documentation.

It is also possible to directly author documents via Zeeq's web interface for quick additions and edits.

❌ Non-Objectives

Things Zeeq aims to not do:

Standardize Workflows

Zeeq does not aim to standardize how developers work with agents. Instead, it aims to provide a common knowledge base that can be leveraged by any agent or workflow.

Replace Developer Judgement

Zeeq is not intended to replace the need for developers to understand their codebase. Instead, it creates a floor of quality by providing a common baseline for every developer.

Prescribe Specific Tools or Agents

By taking an MCP approach, Zeeq is designed to be agnostic to the specific coding agents or tools used by developers. It focuses on providing a knowledge base that can be leveraged by any agent that supports MCP.

Expert Performance on Novel Tasks

Because it is intended to provide guidance for common patterns and practices, Zeeq is not a silver bullet that will solve novel programming tasks or one-offs which are not well fitted to the document set.

Addendum: Background

Zeeq was inspired by several developments in early late 2025 and early 2026:

(13 Feb 2026) SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks

Self-generated Skills provide no benefit on average, showing that models cannot reliably author the procedural knowledge they benefit from consuming. Focused Skills with 2--3 modules outperform comprehensive documentation, and smaller models with Skills can match larger models without them.

Key takeaway: expert, human curated guidance outperforms agent self-generated guidance.

(12 Feb 2026) Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?

Across multiple coding agents and LLMs, we find that context files tend to reduce task success rates compared to providing no repository context, while also increasing inference cost by over 20%... Ultimately, we conclude that unnecessary requirements from context files make tasks harder, and human-written context files should describe only minimal requirements.

Key takeaway: local context files in the repository pollute the local search space and reduces agent performance since agents searching for code will also read incidental matches in the context files that may or may not be canonical.

(01 Oct 2025) Affordable AI Assistants with Knowledge Graph of Thoughts

Knowledge Graph of Thoughts (KGoT) extracts and structures task-relevant knowledge into a dynamic KG representation, iteratively enhanced through external tools such as math solvers, web crawlers, and Python scripts. Such structured representation of task-relevant knowledge enables low-cost models to solve complex tasks effectively while also minimizing bias and noise. For example, KGoT achieves a 29% improvement in task success rates on the GAIA benchmark compared to Hugging Face Agents with GPT-4o mini.

Key Takeaway: advanced context retrieval techniques can improve speed, performance, and context efficiency for coding agents while improving task success rates. Regardless of improvements in the agents, tighter, focused context will always yield performance improvements in speed and task adherence.