The original Signal Pirate article starts from a sentence that is genuinely useful for anyone designing real AI systems: an agent has no shape; it has paths. It is a good correction to the way agentic architecture is often presented: ordered diagrams, seven layers, unavoidable arrows, as if every request had to cross the entire machine.
Production systems rarely behave that way. A definitional question may stop at context and output. An operational task may skip semantic retrieval and call a deterministic tool. A complex analysis may need a knowledge graph, multi-agent orchestration, and stricter guardrails. The agent’s shape emerges from the query, not from the architecture poster.
The diagram is an inventory, not a pipeline
The key distinction is between available components and used components. Input, context, RAG, CAG, knowledge graph, orchestration, tools, output, guardrails, and memory are not a mandatory sequence. They are an inventory of possibilities.
If every request is wired through all of them, the system becomes more expensive, slower, and more fragile. If each layer is treated as an optional capability, the real work becomes routing: deciding which path to take for this query, with this context, in this memory state.
The value of an agent is not the number of layers it contains. It is the quality of the decisions it makes about which layers to use.
This distinction avoids two common mistakes. The first is over-engineering: using multi-agent planning and graph infrastructure where a controlled RAG answer was enough. The second is under-engineering: treating an operational copilot as a chat box with memory when it actually needs actions, permissions, audit trails, and fallbacks.
Why Redis belongs in the conversation
The Redis part of the article is interesting because it moves agent memory away from the local-file metaphor. The new Array type proposed by antirez in Redis PR #15162 introduces an indexed, sparse, server-searchable structure. Commands such as ARSET, ARGREP, and ARINSERT target cases where position has meaning: file lines, time slots, workflow steps, sparse annotations, Markdown documents split into searchable elements.
For an agent, that changes the topology of the knowledge layer. Skills, notes, and knowledge fragments do not have to live in the filesystem of one machine. They can become remote data, shared by multiple processes and searched server-side with patterns.
Redis as backbone, not religion
Redis is already a natural fit for cache, sessions, lightweight queues, event streams, and fast state. With vector search, agent memory, and now the Array/ARGREP direction, it becomes credible as a compact backbone for many pragmatic agents: one process for short-term memory, long-term memory, retrieval, shared state, and signals between agents.
That does not mean Redis should do everything. If the domain requires complex joins, heavy historical analytics, or multi-hop reasoning across millions of entities, a graph database or warehouse can still be the right tool. The point is quieter: you do not need to start with a distributed stack just because the diagram looks more mature. Start from the task, then add complexity when the pain is real.
The router is the new center of the architecture
If an agent is a set of paths, the router is the critical component. It does not always need to be another LLM. In structured domains, simple signals are often enough: keywords, known entities, requested output type, knowledge-graph availability, and action risk.
A request like “what is soffritto?” can use a definitional path. “Convert carbonara for six people” can call a deterministic tool. “Find patterns across Neapolitan recipes” can query a graph and then move into multi-agent synthesis. Same agent, different paths.
The router is therefore a product component, not just an engineering detail. It defines response cost, accepted risk, when memory is consulted, when a tool is used, when human approval is required, and when the system should degrade to a simpler answer.
Memory is not learning
Memory is the sensitive part. An agent can remember, but that does not mean it learns in the strong sense. The model weights do not change. What changes is the external representation: summaries, notes, vectors, events, relations, and previously observed errors.
Every compression is also a loss. A summary replaces part of a conversation. A promotion to long-term memory decides what matters. Decay deletes. For this reason, agent memory should not be treated as a perfect archive, but as an operational narrative: faithful enough to guide the next step, compressed enough to keep the system from saturating.
What to carry into a real project
For a real project, the practical lesson is this:
- design request types before designing the universal diagram;
- decide which layers are required, optional, or forbidden for each class of query;
- keep routing observable, with logs for
PATHand skipped layers; - use memory and retrieval only when they reduce uncertainty, not by habit;
- prefer deterministic tools when the result is numeric, transactional, or verifiable;
- treat Redis as a strong starting point for shared state and memory, not as an automatic answer to every problem.
The original article’s thesis is strong because it cuts the aesthetic power of the diagram down to size. We are not building a creature with a stable silhouette. We are building a controlled space of possibilities, where every query chooses a path.
Technical glossary
AI agent: a system that combines a language model with context, tools, memory, and control rules to decide and act beyond plain text generation.
Layer: a functional part of the architecture, such as input, retrieval, orchestration, tools, output, guardrails, or memory.
Routing: the choice of path for a request. It decides which layers are activated and which are skipped.
RAG: Retrieval-Augmented Generation. The system first retrieves relevant documents from a knowledge base, then passes them to the model to ground the answer.
CAG: Context-Augmented Generation. The system uses already-prepared or structured context, such as application state, summaries, policies, or session data, without necessarily doing semantic retrieval.
Knowledge graph: a representation of entities and relationships. It helps when connections between concepts matter more than text similarity.
Tool call: a call to a function, API, database, or external service. It is how the agent moves from “saying” to “doing.”
Guardrail: a safety, format, policy, privacy, or quality control that validates output and reduces risky errors.
Agent memory: state preserved beyond a single request. It can include history, preferences, errors, documents, vectors, relations, and previous results.
Redis Array: a proposed Redis data type representing indexed sparse arrays. It is useful when an element’s position has semantic meaning.
ARGREP: a proposed command for searching inside a Redis Array with patterns, including regex and glob matching. For agents, it can become a way to search skills or documents server-side.
Sparse system: a structure where only a small number of elements are populated inside a very large index space. The goal is to avoid paying memory for empty space.