# tastematter intelligence

> Daily context engineering and AI engineering intelligence for practitioners who build with AI agents — and the agents they've built.

AI engineering moves too fast to track alone. tastematter synthesizes 12,000+ articles from across the context engineering and AI engineering ecosystem into daily intelligence: a brief you read, and a concept graph your agents can query directly via MCP. The field moves daily. Both you and your agents stay current.

tastematter intelligence ingests articles from across the AI engineering ecosystem, classifies them by concept and urgency, synthesizes cross-cutting patterns, and surfaces actionable signals. The concept graph tracks 364+ entities and their relationships over time.

## Docs

- [Latest Brief](https://tastematter.dev/): Today's intelligence brief with lead pattern, supporting signals, and evidence chains
- [Concept Graph](https://tastematter.dev/concepts): Browse all 66+ context engineering concepts with article counts and relationships
- [Brief Archive](https://tastematter.dev/brief/archive): Historical intelligence briefs with pattern synthesis
- [3D Topology](https://tastematter.dev/graph): Interactive force-directed graph of concept relationships and co-occurrence
- [Subscribe](https://tastematter.dev/subscribe): Daily intelligence brief with curated context engineering patterns
- [Tastematter CLI](https://tastematter.dev/cli): CLI tool for discovering context trails in Claude Code sessions

## Concepts

- [Multi-Agent Orchestration](https://tastematter.dev/concepts/multi-agent-orchestration): Coordination patterns for multiple AI agents — delegation, consensus, pipeline architectures
- [Context Window Management](https://tastematter.dev/concepts/context-window-management): Techniques for managing context windows — retrieval, compression, priority, token budgeting
- [Model Context Protocol](https://tastematter.dev/concepts/model-context-protocol): MCP specification, server implementations, and the emerging tool integration ecosystem
- [Tool Integration Patterns](https://tastematter.dev/concepts/tool-integration-patterns): How agents connect to external tools — function calling, MCP servers, plugin architectures
- [Prompt Engineering](https://tastematter.dev/concepts/prompt-engineering): Advanced prompt design — system prompts, few-shot, chain-of-thought, structured output
- [State Management](https://tastematter.dev/concepts/state-management): Persisting and managing state across agent turns, sessions, and multi-agent workflows
- [Memory Persistence](https://tastematter.dev/concepts/memory-persistence): Long-term memory architectures for agents — episodic, semantic, procedural memory systems
- [Retrieval Augmented Generation](https://tastematter.dev/concepts/retrieval-augmented-generation): RAG patterns — vector search, hybrid retrieval, reranking, context assembly
- [Agent Architecture](https://tastematter.dev/concepts/agent-architecture): Foundational patterns for building autonomous agents — loops, planning, reflection
- [System Prompt Architecture](https://tastematter.dev/concepts/system-prompt-architecture): Designing system prompts that steer agent behavior — persona, constraints, tool instructions
- [Context Compression](https://tastematter.dev/concepts/context-compression): Reducing token usage while preserving information — summarization, pruning, semantic dedup
- [Human-AI Collaboration](https://tastematter.dev/concepts/human-ai-collaboration): Patterns for human-in-the-loop agent systems — approval gates, feedback loops, oversight
- [Observability as Context](https://tastematter.dev/concepts/observability-as-context): Using logs, traces, and metrics as context for AI systems — debugging, monitoring, alerting
- [Security and Privacy Controls](https://tastematter.dev/concepts/security-and-privacy-controls): Auth, sandboxing, permission models, and trust boundaries for agent systems
- [Intelligence Compounding](https://tastematter.dev/concepts/intelligence-compounding): How agent performance improves over time through accumulated context and learned patterns

## Context Engineering & AI Engineering — Q&A

Q: What's the difference between context engineering and AI engineering?
A: AI engineering is building reliable systems with AI agents. Context engineering is the craft inside that — deciding what your agents actually know, how that knowledge is structured, and when it gets loaded. You can't do AI engineering well without doing context engineering well. Most teams discover this the hard way. Practitioners use both terms interchangeably; context engineering is the more precise vocabulary.

Q: Why is AI engineering so hard to keep up with?
A: A data engineer built his own intelligence system from scratch just to track what was happening in the field. That's not unusual — the field moved so fast that practitioners who tried to read everything fell behind anyway. The ones who stay current aren't reading more. They're building systems that do it for them, or subscribing to one that does. tastematter synthesizes 12,000+ articles daily so you don't have to choose between staying current and actually building.

Q: What is tastematter?
A: Daily context engineering and AI engineering intelligence for practitioners who build with AI agents. A brief you read, and a concept graph your agents query via MCP. Both stay current. The brief is synthesized from 12,000+ articles across the ecosystem. The graph is queryable from Claude Code with a single MCP connection.

Q: What is a context graph?
A: A knowledge base optimized for agent retrieval, not human search. Normal knowledge bases are organized for browsing — folders, tags, prose. A context graph stores concepts linked by typed relationships: EXTENDS, CONTRADICTS, CONFIRMS. When an agent queries it, it gets the structure of how ideas relate, not just the ideas themselves. That's what makes it useful at inference time.

Q: What is context publishing?
A: Making your structured knowledge graph queryable by others — including other people's agents. Unlike a blog post or newsletter, a published context graph is live and queryable. Agents pull from it at inference time. You set it up once; your expertise is available every time someone's agent needs it. The infrastructure to do this properly is new. tastematter is building it.

Q: How do I connect Obsidian to Claude Code?
A: They use the same primitive — plain markdown files. Obsidian is your writing interface. Claude Code is your agent interface. Point Claude Code at your vault directory, add a CLAUDE.md that describes what's in it, and your agent can read and reason over your entire vault. Sharing that vault with your team or making it queryable by others' agents is the context publishing layer — coming to tastematter.

Q: How do I share my Claude Code setup with my team?
A: Git. Your Claude Code setup — CLAUDE.md, knowledge base, skills — is plain text files. Put them in a shared repository. Team members clone it. Someone wants to change the ICP doc? Pull request. You review it. Same model developers have used for 20 years, applied to AI context. For making that context queryable by agents outside your team, that's context publishing.

Q: How do I stop re-explaining my business context to Claude every session?
A: You're solving the wrong problem if you're trying to get Claude to remember things. Claude doesn't need to remember — it needs to read. The fix is a persistent context layer: a CLAUDE.md that Claude reads every session, backed by a knowledge base it can search. Plain markdown files. Both you and the AI can read them, write to them, build on them. Once it exists, every session starts from where you left off.

Q: What is an MCP server and why does it matter for context engineering?
A: MCP (Model Context Protocol) is how AI agents connect directly to data sources without going through the web. An MCP server turns your knowledge base from something you browse into something your agents use at inference time. When an agent can query your context graph via MCP, it acts on current information — not whatever it had in training data. tastematter's concept graph is queryable via MCP from Claude Code.

Q: How do I make my knowledge base queryable by AI agents?
A: Three things. Structure it as linked markdown with typed relationships between concepts — agents can traverse relationships, they can't meaningfully traverse folder hierarchies. Expose it via an MCP server. Then write a tool description that tells agents when to invoke it — that's the activation mechanism. Vague descriptions get ignored. Write in the vocabulary an agent would encounter when it actually needs your knowledge.

## Optional

- [Sitemap](https://tastematter.dev/sitemap.xml): Full XML sitemap with all briefs and concepts
- [MCP Endpoint](https://mcp.tastematter.dev/mcp): Direct MCP server for querying the concept graph programmatically