Free tools Windows power users keep installed
One-click scans. No signup required.
An AI-native platform is best built as a governed set of reusable capabilities: model access, data ingestion and retrieval, orchestration, tool execution, state and memory, evaluation, observability, security, and deployment. A model or a vector database is only one part of that set. The practical questions are where retrieval sits in the request path, where orchestration takes control, and which decisions you are willing to hand to a model that can call tools.
This guide walks through the RAG request path, the difference between static and agent-controlled retrieval, the main orchestration patterns, and the controls that matter once software can act. The reference architectures cited here come from AWS and Google Cloud. They are vendor-specific examples, not a universal blueprint.
As an Amazon Associate I earn from qualifying purchases.
The capabilities a platform has to cover
Treat the platform as a set of capabilities that teams can reuse and govern separately. A useful architecture account connects nine areas:
- Model access: how applications reach one or more LLMs, and how that access is authorized and metered.
- Ingestion and retrieval: how source data is parsed, chunked, embedded, and searched.
- Orchestration: the logic that sequences model calls, tools, and retrieval steps.
- Tool execution: the functions an agent can invoke, with their permissions and side effects.
- State and memory: session context, persistent memory, and records of what happened.
- Evaluation: measurement of retrieval quality, response quality, and task outcomes.
- Observability: traces and logs that let operators reconstruct a decision.
- Security: identity, least-privilege access, and data protection across all of the above.
- Deployment: how the components are hosted, scaled, and operated.
Two official references show how these pieces fit together, each on its own stack. AWS’s Agentic AI Lens is a Well-Architected guidance document listed with a June 10, 2026 revision date. Google Cloud’s reference architecture, “RAG infrastructure for generative AI using Agent Platform and AlloyDB for PostgreSQL,” was last reviewed February 4, 2026. Use them to learn the shape of a design, not to copy a stack.
#1 Best Overall
The RAG request path, step by step
Google Cloud’s reference design splits retrieval-augmented generation into an offline ingestion path and an online serving path, with quality evaluation running as a separate subsystem. The sequence below follows that reference. It is one vendor’s illustrative flow, not the only valid one.
Ingestion and indexing (offline)
- Pull source material from files, databases, or streams.
- Parse the raw data and format it into a consistent structure.
- Chunk the content into passages small enough to retrieve and place in a prompt.
- Generate an embedding for each chunk.
- Store the embeddings in an index. The reference uses PostgreSQL with the
pgvectorextension.
The reference says the application should use the same embedding model and parameters for source documents and for user requests. Vectors produced by different models are not directly comparable, so a query embedded with one model will not reliably match passages embedded with another. Treat the embedding model as a versioned dependency: changing it means re-embedding the corpus.
Serving a request (online)
- Embed the user’s request with the same model used at indexing time.
- Run semantic search against the index and retrieve the closest passages.
- Combine the retrieved content with the request to build a contextualized prompt.
- Call the LLM, which produces a response based on the supplied context.
- Screen the response in the application before returning it to the user.
The reference presents this as its intended flow, not a guarantee that grounding eliminates errors. A retrieved passage can be irrelevant, incomplete, or out of date, and the model can still misread a correct one. Screening and evaluation exist because of that gap.
Recommended Free Tools
Evaluation as a running subsystem
The Google Cloud reference places evaluation in its own subsystem, which assesses responses on measures such as factual accuracy and relevance. Build it as a continuing activity: run a fixed test set before launch, then sampled production traffic, and repeat after any change to the embedding model, chunking, prompts, or the LLM. Inspect retrieval quality and response quality as separate things. A correct answer from weak retrieval can be coincidental, and strong retrieval can still produce a poor answer. The reference’s measures are examples; the source does not establish that they transfer unchanged to every deployment.
Choosing where retrieval lives
A vector database is one design choice inside RAG, not the architecture itself. Google Cloud’s “Generative AI with RAG” architecture index (reviewed September 22, 2025) documents several options, summarized below. The comparison axes are editorial, drawn from those options. They are not a benchmark or a scored vendor ranking.
| Option | What the sources document | Trade-offs to compare |
|---|---|---|
| Managed vector search | A managed retrieval service in Google Cloud’s RAG overview | Operating burden against customization. Performance and cost comparisons: not stated in the cited sources. |
| PostgreSQL with vector support | Vectors stored alongside operational data; the reference architecture uses pgvector |
Fit with existing operational data. Behavior at very large index sizes: not stated in the cited sources. |
| Container-based open-source route | Open-source components deployed in containers | Greater control over components, with more of the operating work on your team. |
| Graph plus vector retrieval | Combining vector similarity with graph relationships, as described in the overview | Suited to relationship-heavy questions. Adds modeling and maintenance work. |
What makes a system agentic
Define an agentic system by behavior: a model interprets a goal, selects actions, may invoke tools, and may continue through several steps before it answers. AWS’s definitions page for the Agentic AI Lens distinguishes three shapes: a single agent using multiple tools, specialized agents coordinated together, and hybrid systems that combine agents with conventional software. Hybrids suit platforms where some steps should stay deterministic ordinary code, such as validation rules or approvals, while others need model judgment.
Orchestration and the agentic patterns
Orchestration is the control layer for multi-step work. It decides which tools to call, in what sequence, and how to use their outputs. AWS’s guide “Agentic AI patterns and workflows on AWS,” by Aaron Sempf and Andrew Hooker, documents individual agent patterns, LLM workflow patterns, and delegation or multi-agent workflows. The five patterns below are the ones worth distinguishing when you design.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Tool-using agent
The model chooses among authorized tools as it works through a task. The design question is the permission boundary: what each tool can read or change, and who approves the change. Tool output also feeds back into the model, so a tool that returns untrusted text can influence later decisions. Treat tool results as data to be checked, not as instructions to follow.
Rank #3
Workflow orchestrator
A control component sequences fixed steps and combines their results. The flow is inspectable, and each step can be tested on its own. Choose this pattern when the steps are known and repeatable, such as fixed-format extraction from documents.
Delegation and supervisor-worker
A coordinating component assigns subtasks to specialist roles and assembles the results. It helps when subtasks differ meaningfully in tools or context. Each delegation adds a handoff, and each handoff adds latency, a point where context can be lost, and another component that can fail.
Event-based coordination
Agents or services coordinate by publishing and reacting to events inside a broader cloud-native workflow. This fits work that is already event-driven, such as responding to a new ticket or an uploaded document. The overall flow is harder to read from one place, so invest in tracing across events.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Agentic RAG
Retrieval becomes an action inside the reasoning loop. The agent can decide whether to retrieve at all, decompose a question into sub-queries, choose among retrieval tools, retrieve again, and judge whether the context it holds is sufficient to answer. Those adaptive decisions are what separate agentic RAG from the static path described above.
Avoid equating more agents with better architecture. AWS’s guidance identifies coordination overhead, handoff complexity, and distributed failure modes as costs of multi-agent designs.
Static retrieval or agent-controlled retrieval
The main architectural choice inside RAG is who decides when and how to retrieve. The table compares the two approaches.
| Dimension | Static retrieval in the request path | Agentic RAG |
|---|---|---|
| Who decides retrieval | The application, on every request | The agent, which may retrieve zero, one, or several times |
| Query handling | The user’s request is embedded as written | The agent can decompose the request into sub-queries |
| Sufficiency check | The reference flow does not include one; the response moves to generation and screening | The agent judges whether retrieved context is enough and can search again |
| Predictability | High; one retrieval step per request | Lower; the number of steps varies by request |
| Cost and latency | Fixed: one retrieval and one generation call, plus screening | Rises with each additional model step and retrieval call |
State, memory, and records of action
Three kinds of state need separate design decisions:
- Session context: what the current conversation or task needs. It is usually discarded when the session ends.
- Persistent memory: information kept across sessions, such as user preferences or prior decisions. AWS’s definitions treat memory as a distinct component.
- Durable records of actions: an audit trail of what the agent did, which tools it called, and with what inputs and outputs.
Each carries different privacy, data integrity, retention, and audit requirements, plus its own storage cost. Persistent memory can hold personal data long after a session ends, so it needs explicit retention rules and a way to correct or delete entries. Action records need to be trustworthy enough to support an investigation, which means controlling who can write and alter them.
Production controls when software can act
AWS’s Agentic AI Lens frames the production question this way: organizations deploying agentic AI are moving from asking “can we build an agent?” to asking “can we run agents reliably, securely, and cost-effectively at scale?” The guidance notes that agent systems may make multiple model calls and tool invocations per request, which creates latency, cost, and failure surface. It names autonomy, stochastic behavior, persistent memory, and agent collaboration as distinct architecture concerns.
Permissions and oversight
- Bound each agent’s scope, give each tool the least privilege it needs, and require strong identity for every action.
- Match human review to the risk and reversibility of an action. Read-only lookups rarely need approval; changes to money, records, or access usually do.
Observability and evaluation
- Log and trace each model call, retrieval, and tool action, so operators can reconstruct what happened and why.
- Evaluate task outcomes and behavior, not only deterministic unit tests. Model behavior can vary across runs, so run the same scenario several times and examine the spread of results.
Resilience and cost
- Plan for graceful degradation: define what the system does when retrieval, a tool, or the model is unavailable, and which partial functions remain.
- Add retries or recovery where a step is safe to repeat, and avoid blind retries on actions with side effects.
- Track model, memory, orchestration, and coordination costs as part of design and operation, since every extra model call adds to the bill.
Decision checklist
Use these questions to pick the simplest architecture that meets the workload. Compare managed against customizable infrastructure, and weigh retrieval needs, security, reliability, latency, evaluation requirements, and cost.
- Start with static RAG if questions follow a predictable pattern and one retrieval step can answer them. Build evaluation before adding agency.
- Add workflow orchestration when the steps are known and you need an inspectable sequence.
- Add agentic retrieval only when questions need decomposition, several sources, or sufficiency checks, and you can measure whether the added steps improve answers.
- Add delegation or multiple agents only when subtasks differ enough in tools or context to justify the handoffs, and you can trace each one.
- Choose a retrieval store by matching it to where your operational data already lives, how relationship-heavy your questions are, and how much customization you need.
What the sources do not establish
The cited documentation supports architecture patterns and vendor implementations. It does not establish comparative performance, cost rankings, or a universally best platform. The sources contain no cross-industry statistics and no numerical benchmarks. Any claim that one retrieval store or orchestration pattern is faster or cheaper needs a benchmark run on your own workload.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
