No-Code and Agentic AI experimental

No-Code and Agentic AI Design, evaluate, and govern AI-driven workflows, from clustering and regression through large language models, retrieval-augmented generation, and multi-agent orchestration, without writing a single line of code, benchmarked against MIT Professional Education's No Code and Agentic AI program. Foundations: The No-Code Path Through the AI Landscape. The architectural arc from rule-based systems to agentic AI, and what a no-code platform abstracts away. Describe the architectural arc from rule-based systems through machine learning, deep learning, transformers, generative AI, to agentic systems, and name the key breakthrough at each transition. Explain what a no-code platform abstracts away from a coded pipeline, and construct an example of one class of problem that abstraction cannot solve. Rule-based and symbolic AI: the 1955 Dartmouth proposal, The statistical learning shift: machine learning, Deep learning and representation learning, The transformer breakthrough and generative AI, From generation to action: agentic AI, What no-code abstracts, and where it breaks down Module 0. Foundations: The No-Code Path Through the AI Landscape The architectural arc Artificial intelligence (AI) did not arrive as a single technology. It moved through a sequence of architectural paradigms, each one absorbing and reframing the paradigm before it. The field's own founding document, the 1955 Dartmouth proposal by McCarthy, Minsky, Rochester, and Shannon, coined the term "artificial intelligence" and set the research agenda that the rest of this arc grew out of (McCarthy et al., 1955). The transformer transition (Vaswani et al., 2017) is the hinge point of this entire arc. Before it, sequence models (recurrent networks) processed a sentence one token at a time, in order, which limited both training speed and how far back in a sequence a model could "remember." Self-attention let every token attend to every other token in a single pass, in parallel, and it is this architecture, scaled up, that underlies every large language model this course discusses from Module 6 onward. What a no-code platform abstracts away A no-code platform (this course uses CCICCS's own deterministic in-browser workflow simulator, benchmarked against real tools such as Konstanz Information Miner (KNIME) and n8n) lets a learner assemble a working pipeline by connecting visual nodes rather than writing source code. What it abstracts away is the implementation: the exact matrix operations inside a transformer layer, the training loop that updates a model's weights, the low-level API calls that move data between systems. This abstraction is genuinely useful for the great majority of business applications of AI: a workflow that clusters customers, forecasts a number, retrieves a relevant document, or routes a support ticket to the right agent does not require the operator to write that clustering, forecasting, retrieval, or routing logic by hand. But the abstraction has a floor. Highly novel research architectures, bespoke low-level performance optimization, and genuinely new model training from scratch still require custom code that a purely node-based interface cannot express. Recognizing that floor, knowing when a problem has outgrown a no-code layer and needs a specialist, is itself a professional skill this course treats as part of foundational literacy, not an afterthought. Where this course sits This course, LOOM (LOOM), is the no-code companion to SYNAPSE (AI Foundations, Level I), which teaches the same conceptual arc through code and notebooks. LOOM does not re-teach deep learning architecture or computer vision in depth; both are already owned by SYNAPSE and by ODYSSEY (Adversarial ML and Generative-AI Security, Level III) elsewhere in this catalogue. LOOM instead concentrates on the classical machine learning and generative and agentic arc a no-code practitioner most needs, closing in Module 10 with a dedicated lesson on agentic-AI attack surface that cross-references ODYSSEY's deeper technical treatment. References McCarthy, J., Minsky, M. L., Rochester, N., & Shannon, C. E. (1955). A Proposal for the Dartmouth Summer Research Project on Artificial Intelligence. http://jmc.stanford.edu/articles/dartmouth/dartmouth.pdf. Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS 2017. https://arxiv.org/abs/1706.03762 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Building Your First Workflow. Node-based visual pipelines, source/transform/sink nodes, and predicting a workflow's output before running it. Build a linear no-code workflow (source, transform, sink) and correctly predict its output before running it. Compare a node-based data-pipeline tool with a workflow-orchestration/automation tool and identify which is the better fit for a stated business scenario. Node-based visual programming, Source, filter, join, transform, and sink node types, KNIME as a data-pipeline exemplar, n8n as a workflow-orchestration exemplar, Execution order and data flow Module 1. Building Your First Workflow Node-based visual pipelines A no-code workflow is a directed graph of nodes connected by edges that carry data from one node to the next. Three node roles recur in almost every workflow this course builds: A source node brings external data into the workflow: a file, a database table, or an API response. Transform nodes then filter, join, aggregate, or otherwise reshape that data. A sink node is the endpoint, writing the processed result to a file, a dashboard, or a downstream system. Execution order is determined by the direction of the edges, not by the order nodes were drawn on the canvas: a filter node placed before an aggregation node changes what the aggregation sees, and a filter node placed after it does not. Because each node's output can typically be previewed independently before the rest of the workflow runs, a learner can validate an assumption about one transform node in isolation rather than waiting for the entire pipeline to finish. This mirrors the value of predicting a pipeline's output in advance: previewing a single node's result immediately after building it, before wiring in the next node, catches a wrong assumption about a filter condition or a join key at the exact point it was introduced, rather than several steps downstream where the original cause is harder to trace. Two companion tools, two different jobs Konstanz Information Miner (KNIME), formally organized as KNIME AG (Aktiengesellschaft (AG), the German public company designation), is an open-source visual analytics platform built around exactly the source-transform-sink pattern above: a data scientist or analyst assembles a pipeline of nodes to clean, join, and analyze a dataset. n8n (n8n GmbH) is an open-source workflow-automation tool built for a different job: triggering a sequence of actions across services when an event happens, for example when a support ticket arrives, classify it, route it to a team, and log it. Neither tool is "better" in the abstract; the right choice depends on whether the job is data transformation on a known dataset (KNIME's strength) or triggered orchestration across systems (n8n's strength). This course's own in-browser simulator lets a learner practice both patterns without installing either tool. Predicting output before running Before running a newly assembled workflow, this course asks the learner to predict its output on paper or in the simulator's prediction panel. This is not busywork. A learner who predicts that a join on a mismatched key will produce far fewer rows than expected, and then runs the workflow and sees exactly that, has caught a real design error before it propagated downstream. A learner who only ever clicks "run" and reads whatever comes out never builds the habit of reasoning about a pipeline's behavior in advance, and is far more likely to accept a silently wrong result as correct. References KNIME AG. KNIME Analytics Platform. https://www.knime.com/. n8n GmbH. n8n, workflow automation platform. https://n8n.io/ Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Data Exploration and Unsupervised Learning. K-means, hierarchical clustering, GMM, PCA, and t-SNE, applied without labels. Apply k-means clustering to segment a dataset and interpret the resulting clusters. Use PCA to reduce dimensionality and explain what a principal component represents. K-means clustering (MacQueen, 1967), Hierarchical clustering and dendrograms, Gaussian mixture models, Principal component analysis (Pearson, 1901), t-SNE for visualization (van der Maaten and Hinton, 2008) Module 2. Data Exploration and Unsupervised Learning Clustering without labels Unsupervised learning finds structure in data that carries no pre-assigned labels. K-means, the most widely used clustering method, was formalized by MacQueen in 1967 (MacQueen, 1967). It works by an iterative two-step process: assign each point to its nearest of k cluster centroids, then recompute each centroid as the mean of the points assigned to it, repeating until assignments stop changing. K-means requires the analyst to choose k in advance, and its result can be sensitive to where the initial centroids happen to land. Hierarchical clustering avoids the need to fix k up front: it builds a nested tree of clusters, a dendrogram, that can be cut at any level to yield a different number of clusters, letting the analyst inspect the structure before committing to a specific k. A Gaussian Mixture Model (GMM) takes a different approach again. Rather than assigning each point to exactly one cluster, a GMM models each cluster as a probability distribution and gives each point a soft, probabilistic membership across all clusters, which is useful when real clusters overlap rather than sitting in cleanly separated regions. Reducing dimensionality Principal Component Analysis (PCA), introduced by Pearson in 1901 (Pearson, 1901), finds new axes, called principal components, ordered by how much of the data's variance they capture. Projecting a dataset onto its first few principal components can compress dozens of correlated columns down to a handful of numbers with minimal information loss, which is useful both for visualization and as a preprocessing step before other techniques. Stochastic Neighbor Embedding (SNE), an earlier technique introduced by Hinton and Roweis in 2002, was extended by van der Maaten and Hinton's 2008 t-SNE (t-distributed Stochastic Neighbor Embedding) variant (van der Maaten & Hinton, 2008), which modified it to use a Student's t-distribution in the low-dimensional space. t-SNE is built for a narrower job: visualizing high-dimensional data in two or three dimensions by preserving local neighborhood structure, so points that were close together in the original high-dimensional space tend to remain close together in the visualization. Unlike PCA, t-SNE is not generally used as a preprocessing step for further modeling; it is a visualization tool for a human analyst to inspect. Why this comes before regression This module sits immediately after Module 1's workflow mechanics and immediately before Module 3's introduction of supervised learning. That ordering is deliberate: unsupervised exploration is the natural first step when data exists but no labeled target has yet been defined, and the patterns it surfaces, how many natural customer segments exist, which features carry redundant information, often inform which supervised technique and which features to use next. References MacQueen, J. (1967). Some Methods for Classification and Analysis of Multivariate Observations. Proceedings of the Fifth Berkeley Symposium on Mathematical Statistics and Probability, 1, 281-297.. Pearson, K. (1901). On Lines and Planes of Closest Fit to Systems of Points in Space. Philosophical Magazine, 2(11), 559-572. https://doi.org/10.1080/14786440109462720. van der Maaten, L., & Hinton, G. (2008). Visualizing Data using t-SNE. Journal of Machine Learning Research, 9, 2579-2605. Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Prediction: Regression. Linear regression, coefficient interpretation, and R-squared, RMSE, and MAE. Fit and explain a linear regression model, including coefficient sign and magnitude. Select and apply the correct evaluation metric (R-squared, RMSE, MAE) for a stated regression scenario. Galton's 1886 origin of the term 'regression', Linear regression and coefficient interpretation, R-squared, RMSE and MAE, Testing basic statistical assumptions Module 3. Prediction: Regression Where the word "regression" comes from Francis Galton's 1886 study, "Regression towards Mediocrity in Hereditary Stature," analyzed the heights of 928 adult children against those of 205 parent pairs and found that children of unusually tall or unusually short parents tended toward the population average rather than matching their parents' extremity (Galton, 1886). Galton called this tendency "regression," and the term stuck, first as a description of that specific biological phenomenon, later as the name for the entire statistical technique of fitting a line or curve to predict one variable from others. Every time this course, or any other source, uses the word "regression" for a predictive model, it is a direct descendant of Galton's 1886 vocabulary. Fitting and reading a linear regression A linear regression model predicts a numeric outcome as a weighted sum of input variables plus an intercept. Each input variable's coefficient carries a sign and a magnitude: a positive coefficient means that increasing that variable is associated with an increase in the predicted outcome, holding the other variables constant, and a negative coefficient means the opposite. Coefficient magnitude alone, without accounting for the scale of the variable it belongs to, does not directly indicate which variable matters most; a coefficient of 1000 on a variable measured in millions can matter less than a coefficient of 2 on a variable measured in single units. Three evaluation metrics, three different questions R-squared measures the proportion of variance in the outcome that the model explains, generally on a scale from 0 to 1. Root Mean Squared Error (RMSE) and Mean Absolute Error (MAE) both measure the typical size of prediction error, but they answer different business questions. RMSE squares each error before averaging, which means a few very large errors drive the metric up disproportionately; it is the right choice when large misses are especially costly, for example wildly underpricing a single large order. MAE averages the absolute size of errors with no such penalty; it is the right choice when every unit of error carries roughly the same cost regardless of size. A caution about training-data performance A strong R-squared computed on the same data used to fit the model does not by itself guarantee the model will perform as well on new, unseen data; a model can fit its training data closely while generalizing poorly. This module also asks learners to sanity-check basic assumptions, for example a roughly linear relationship between inputs and the outcome, before trusting a regression's coefficients, since violating those assumptions can produce misleading coefficients even when the workflow runs without any visible error. References Galton, F. (1886). Regression towards Mediocrity in Hereditary Stature. Journal of the Anthropological Institute of Great Britain and Ireland, 15, 246-263. https://www.stat.ucla.edu/~nchristo/statistics100C/history_regression.pdf Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Prediction: Classification and Ensembles. Decision trees, random forests, confusion matrices, and precision, recall, and F1. Build a decision tree classifier and interpret a split. Explain how random forests reduce variance relative to a single decision tree, and compute precision, recall, and F1 from a confusion matrix. Decision trees, Random forests (Breiman, 2001), Confusion matrices, Precision, recall, and F1, Using large language models for text classification Module 4. Prediction: Classification and Ensembles Decision trees and the ensemble idea A decision tree classifies a case by following a sequence of if-then splits on input features down to a leaf node that assigns a class label; each split is chosen to best separate the classes at that point in the data. A single tree, however, tends to overfit: it can carve out splits that fit the training data's noise rather than any real, generalizable pattern. Breiman's 2001 paper, "Random Forests," addressed this by combining many trees rather than relying on one (Breiman, 2001). Each tree in a random forest is trained on a random subset of the data and a random subset of features, and the forest's final prediction aggregates every tree's vote. Averaging many decorrelated trees reduces the variance any single overfit tree would introduce, which is why a random forest typically generalizes better than a lone decision tree, even though it does not train faster than one. Reading a confusion matrix A confusion matrix for a binary classifier cross-tabulates predicted class against actual class, yielding four counts: true positives, true negatives, false positives (predicted positive, actually negative), and false negatives (predicted negative, actually positive). Which metric to optimize for is a business decision, not a purely technical one. A fraud-detection system where missing real fraud is far costlier than an occasional false alarm should generally prioritize recall, accepting more false positives in exchange for catching more actual fraud. A system where false alarms themselves are very costly, for example an automated account-suspension trigger, should weight precision more heavily. A worked example clarifies how these formulas combine: a classifier that produces 90 true positives, 10 false negatives, 20 false positives, and 880 true negatives yields a recall of 90 divided by 100, or 90 percent, and a precision of 90 divided by 110, or about 82 percent. The F1 score, the harmonic mean of the two, sits close to but not exactly at their simple average, reflecting how heavily F1 penalizes a large gap between precision and recall rather than rewarding a high score in one at the expense of the other. Large language models as classifiers This module notes that a large language model can also perform a classification task directly, for example sorting incoming support tickets into categories from their text, using its general language understanding rather than a model trained specifically for that one task. This is a legitimate alternative or complement to a traditional trained classifier, particularly useful where labeled training data for the specific category set is scarce; it is not a replacement for the decision-tree and ensemble techniques covered here, which remain the right choice when structured, labeled training data is already available. References Breiman, L. (2001). Random Forests. Machine Learning, 45, 5-32. https://doi.org/10.1023/A:1010933404324 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Recommendation Systems. Rank-based, content-based, and collaborative-filtering recommenders, and the cold-start problem. Distinguish rank-based, content-based, and collaborative-filtering recommenders. Diagnose the cold-start problem and design a mitigation. Rank-based recommendation, Content-based filtering, Collaborative filtering, Matrix factorization (Koren, Bell, and Volinsky, 2009), The cold-start problem Module 5. Recommendation Systems Three families of recommender A rank-based recommender is the simplest approach: it surfaces the same globally most popular or highest-rated items to every user, with no personalization at all. A content-based recommender personalizes by matching the attributes of items a user has liked before against the attributes of candidate items. Collaborative filtering personalizes differently again: it relies on patterns of interaction across many users, recommending items liked by users whose behavior resembles the target user's, which can surface serendipitous recommendations outside anything the user has explicitly stated a preference for. Matrix factorization Koren, Bell, and Volinsky's 2009 paper, drawing directly on techniques that proved decisive in the Netflix Prize competition, formalized matrix factorization for recommender systems (Koren, Bell, & Volinsky, 2009). The idea is to decompose a large, sparse user-item ratings matrix, where most user-item pairs have no observed rating at all, into two lower-dimensional latent factor matrices, one for users and one for items. The product of a user's latent vector and an item's latent vector approximates that user's known rating for that item where one exists, and predicts a rating where one does not. Matrix factorization does not require every cell of the ratings matrix to be observed; its entire value lies in working well on sparse data, and it was shown during the Netflix Prize to outperform classic nearest-neighbor collaborative filtering approaches. The cold-start problem The cold-start problem is the difficulty of recommending anything sensible to a brand-new user, or for a brand-new item, when little or no interaction history exists yet to learn from. A practical mitigation is to fall back to a rank-based or content-based approach, using whatever profile attributes are available, until enough interaction data accumulates for collaborative filtering or matrix factorization to become reliable; refusing to serve any recommendation at all, or defaulting to random selection, are both worse outcomes than a reasoned fallback. Why recommenders sit here in the sequence Recommendation systems are placed after regression (Module 3) and classification (Module 4) because a working recommender often reuses ideas from both: predicting a numeric rating draws on regression-style reasoning, and predicting a binary like or dislike draws on classification-style reasoning, applied here to a specific, recurring business problem structure. References Koren, Y., Bell, R., & Volinsky, C. (2009). Matrix Factorization Techniques for Recommender Systems. Computer, 42(8), 30-37. https://doi.org/10.1109/MC.2009.263 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Large Language Models and Prompt Engineering. Self-attention, in-context learning, few-shot and chain-of-thought prompting, hallucination, and alignment. Explain the transformer's self-attention mechanism at a conceptual level and why it enabled scaling. Apply a named prompt-engineering technique to improve output reliability. Self-attention and the transformer, In-context and few-shot learning (Brown et al., 2020), Chain-of-thought prompting (Wei et al., 2022), Hallucination, Alignment Module 6. Large Language Models and Prompt Engineering Self-attention, briefly revisited Module 0 introduced the transformer's self-attention mechanism (Vaswani et al., 2017) as the hinge point of the AI architectural arc. This module treats it conceptually rather than mathematically: self-attention lets a model weigh the relevance of every other token in a sequence when computing the representation of a given token, which is what allows a large language model (LLM) to capture relationships between words that are far apart in a sentence or document, something recurrent architectures struggled to do at scale. In-context and few-shot learning Brown et al.'s 2020 paper, "Language Models are Few-Shot Learners," demonstrated that a sufficiently large language model could perform many tasks reasonably well given only a handful of examples placed directly in the prompt, with no task-specific retraining of its weights at all (Brown et al., 2020). This capability, in-context learning, is what makes prompt engineering possible: the model adapts its behavior to instructions and examples supplied at inference time, not by updating its underlying parameters. Chain-of-thought prompting Wei et al.'s 2022 paper showed that prompting a large language model to generate intermediate reasoning steps before its final answer, chain-of-thought prompting, measurably improved performance on complex reasoning tasks compared to asking for a direct answer alone (Wei et al., 2022). Asking a model to "think step by step" before answering is a direct, practical application of this technique. Two persistent limitations Hallucination is the tendency of a language model to generate fluent, confident-sounding text that is factually incorrect or unsupported by any real source; it is not a rare edge case but a structural property of how these models generate text, and it is the central motivation for Retrieval-Augmented Generation, covered next in Module 7. Alignment concerns whether a model's outputs and behavior reliably reflect the intentions and values of its designers and users, rather than producing harmful, misleading, or off-task content; it is an active, unresolved area of research, not a solved problem. A no-code workflow that sends a user's question directly to a large language model with no external data source connected is most exposed to hallucination, since the model has no mechanism to verify its answer against a current or proprietary source of truth. That gap is exactly what Module 7's Retrieval-Augmented Generation pipeline is built to close. References Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS 2017. https://arxiv.org/abs/1706.03762. Brown, T., et al. (2020). Language Models are Few-Shot Learners. NeurIPS 2020. https://arxiv.org/abs/2005.14165. Wei, J., et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS 2022. https://arxiv.org/abs/2201.11903 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Retrieval-Augmented Generation. Chunking, embeddings, vector retrieval, and grounded generation. Describe the RAG pipeline (chunk, embed, retrieve, generate) and explain why grounding reduces hallucination. Apply an appropriate chunking strategy for a stated document type. The RAG pipeline (Lewis et al., 2020), Chunking strategies, Embeddings and vector similarity, Retrieval and grounded generation, What RAG does and does not fix Module 7. Retrieval-Augmented Generation The RAG pipeline Lewis et al.'s 2020 paper introduced Retrieval-Augmented Generation (RAG): pairing a language model with an external retrieval system that supplies relevant documents or passages for the model to ground its generated answer in, rather than relying solely on whatever knowledge is encoded in the model's own trained parameters (Lewis et al., 2020). Chunking splits a source document into smaller, retrievable passages sized to fit the pipeline's retrieval and generation constraints. A chunking strategy that respects a document's natural structure, splitting a legal contract by clause rather than by a fixed character count, for example, tends to produce more coherent, complete units of meaning, which improves what retrieval can find and what the model can ground its answer in. An embedding is a numerical vector representation of text positioned in a space where semantically similar content sits closer together; once both the document chunks and the incoming query are embedded, retrieval searches the indexed chunk embeddings for those most similar to the query embedding and returns the top-ranked matches for the model to use as grounding context. In the final generation step, the top-ranked retrieved chunks are inserted into the model's prompt as supporting context alongside the user's original query, and the model is instructed to base its answer on that supplied material rather than on unconstrained recall from its own trained parameters. A financial-services chatbot restricted to a company's own current policy documents illustrates the pattern end to end: a policy question is embedded, the retrieval step returns the clauses most similar to that question from an indexed corpus of the company's own documents, and the model composes its answer from those retrieved clauses, drawing on that retrieved material rather than on general training data that might be outdated or simply wrong for that organization's specific policy. What RAG fixes, and what it does not RAG reduces, without fully eliminating, hallucination. Retrieval quality, chunking choices, and how the model handles the retrieved content can all still introduce errors: if retrieval returns chunks only loosely related to the actual question, the model tends to make use of whatever context it is given, so a generated answer may still end up grounded in irrelevant or misleading material. RAG is best understood as extending, not replacing, the generative-AI paradigm introduced in Module 6: it combines a generative model's fluency with an external, verifiable knowledge source, a natural language processing (NLP) technique for grounding open-ended generation in retrievable evidence. References Lewis, P., et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. NeurIPS 2020. https://arxiv.org/abs/2005.11401 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Evaluating Generative AI Systems. Reference-based metrics, LLM-as-judge, and consistency-check hallucination detection. Explain when to select an appropriate evaluation metric (reference-based vs. reference-free) for a stated generation task. Design a consistency check to detect a hallucination. Reference-based evaluation, LLM-as-judge (Zheng et al., 2023), Biases in LLM-as-judge evaluation, Consistency-check hallucination detection, Prompt optimization Module 8. Evaluating Generative AI Systems Reference-based versus reference-free evaluation When a ground-truth reference output exists, for example a known correct translation or a reference summary, reference-based metrics compare a model's output directly against that reference. Many generative tasks have no single correct reference, however: an open-ended chatbot response, a creative brief, a business recommendation. For these, Zheng et al.'s 2023 paper examined "Large Language Model (LLM)-as-judge" evaluation, using a strong language model to assess and score another model's outputs against stated criteria, as a reference-free alternative to human evaluation at scale (Zheng et al., 2023), introducing the Multi-Turn Benchmark, MT-Bench (MT), evaluation suite alongside the Chatbot Arena leaderboard for this purpose. Zheng et al.'s own findings identified real limitations in LLM-as-judge evaluation: verbosity bias, favoring longer responses regardless of actual quality, and self-enhancement bias, favoring outputs stylistically similar to the judge model's own output, along with limited reasoning ability on certain question types. These are documented weaknesses, not reasons to discard the technique, but reasons to combine it with other checks rather than trust it alone. Consistency checks for hallucination A consistency check asks the model the same underlying question multiple times, rephrased, and checks whether the answers remain factually consistent with each other. Materially different factual answers to the same underlying question is a signal that at least one of them may be an unreliable, hallucinated response, warranting further scrutiny before either is trusted. Prompt optimization Prompt optimization is the iterative refinement of prompt wording, structure, or examples based on evaluation results, improving output reliability over successive rounds. It is not a one-time step performed once and forgotten; it is a recurring part of maintaining any generative AI workflow in production. A concrete cycle illustrates the practice: a team evaluates a customer-support chatbot's responses using LLM-as-judge scoring, discovers that responses to multi-part questions are answered incompletely and score noticeably lower, and revises the prompt to explicitly instruct the model to address every sub-question before finishing its answer. Re-running the same evaluation against the revised prompt on the same set of representative test queries shows whether the change measurably improved the score, closing the loop between evaluation and prompt design rather than treating the two as separate, one-off activities. This module's evaluation techniques apply most directly to output produced by Modules 6 and 7, large language models and prompt engineering, and Retrieval-Augmented Generation. It is placed immediately before the agentic modules (9 and 10) because an agent's individual actions and outputs are themselves generated content that benefits from the same evaluation discipline; establishing evaluation technique here equips learners to apply it to agent behavior next. References Zheng, L., et al. (2023). Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena. NeurIPS 2023. https://arxiv.org/abs/2306.05685 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Agentic AI I: Single-Agent Systems. The perceive-plan-act loop, tool use, memory, and a light conceptual grounding in reward and policy. Describe the perceive-plan-act loop and the role of memory and tool use in an autonomous agent. Distinguish a reactive LLM call from an agentic system, and build a minimal example that demonstrates the difference. Reward and policy, conceptually, ReAct: interleaving reasoning and acting (Yao et al., 2022), From reactive LLMs to autonomous agents, Tool use, Memory and planning Module 9. Agentic AI I: Single-Agent Systems From reactive model to acting agent A plain large language model, as covered in Module 6, is reactive: it produces one response to one prompt and stops. An agentic system adds the ability to plan a multi-step sequence of actions, invoke external tools, and retain memory across steps, turning a single response into an extended, goal-directed process. A light grounding in reward and policy This course borrows two concepts from reinforcement learning at a conceptual level, without requiring any learner to implement a reinforcement-learning algorithm directly. A policy is the strategy or mapping an agent uses to decide which action to take given its current state. A reward signal provides feedback on how good or bad an action's outcome was, which the agent's policy can be improved against over time. Most no-code agent tools do not expose this machinery directly, but the vocabulary gives learners a way to reason about how an agent's behavior can improve based on feedback, rather than treating an agent's decisions as an unexplainable black box. ReAct: reasoning and acting together Yao et al.'s 2022 paper, "ReAct: Synergizing Reasoning and Acting in Language Models," published in October 2022, ahead of the wave of consumer agent frameworks that followed, interleaves verbal reasoning traces with task-specific actions (Yao et al., 2022). This lets a language model create, maintain, and adjust a plan while interacting with an external environment, rather than committing to a single fixed plan up front and executing it blindly. Tool use and memory Tool use is an agent's ability to invoke external functions, APIs, or services, a search engine, a calculator, a database query, as part of completing a task, rather than being limited to producing plain text. Memory lets an agent retain relevant information from earlier steps so that later decisions can be informed by what has already happened in the same task, rather than starting from a blank context at every step. A task-oriented workflow that researches a topic, drafts a summary, and then checks that summary against the retrieved sources before finalizing it combines all three elements this module introduces: planning the sequence of steps, tool use for research and retrieval, and a form of self-checking characteristic of agentic systems. This module is placed immediately before multi-agent orchestration in Module 10 because understanding how a single agent plans, remembers, and uses tools is the necessary foundation before reasoning about how multiple such agents coordinate with each other. References Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. https://arxiv.org/abs/2210.03629 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Agentic AI II: Multi-Agent Orchestration and Agentic Security. Task routing, error handling, adaptive retrieval, and a dedicated lesson on prompt injection and excessive agency. Design a multi-agent workflow with task routing and handoff between agents. Identify at least one agentic-AI-specific attack surface (prompt injection, excessive agency, tool misuse) and state the mitigating control. Multi-agent collaboration and task routing, Handling uncertainty and errors across agents, Adaptive retrieval, Measuring multi-agent effectiveness, Agentic AI attack surface: prompt injection and excessive agency (OWASP Top 10 for LLM Applications); cross-reference to ODYSSEY Module 10. Agentic AI II: Multi-Agent Orchestration and Agentic Security Coordinating more than one agent A multi-agent system involves multiple agents, each potentially specialized for a sub-task, coordinating, handing off work, or collaborating toward a shared goal. Task routing directs a given task or sub-task to the agent or tool best suited to handle it, based on the task's nature. Adaptive retrieval adjusts what is retrieved, or whether retrieval happens at all, based on the current sub-task or agent's specific need within the larger workflow, rather than applying one fixed retrieval configuration everywhere. Measuring the effectiveness of a multi-agent system means looking at tool-use accuracy and task-completion quality across the handoffs between agents, not just each individual agent's output in isolation; a system where every individual agent performs well in isolation can still fail overall if handoffs lose information or context. Handling uncertainty and errors requires a fallback or retry strategy, and potentially escalation to a human, so that a single failed step, one agent's tool call failing, does not silently corrupt the whole workflow's final output. Agentic-AI attack surface The same coordination surface that makes multi-agent orchestration powerful, task handoff, tool access, delegated permissions, is exactly what creates its distinctive security risks. This lesson draws on the Open Web Application Security Project (OWASP) Top 10 for Large Language Model Applications (OWASP Foundation, 2025), which names two risks directly relevant here. Prompt injection is crafted input designed to manipulate a model's behavior, potentially bypassing its intended instructions, in order to gain unauthorized access or influence its decisions; unlike ordinary prompt engineering, it is an adversarial technique aimed at subverting a system rather than legitimately guiding it. Excessive agency describes a situation where a system grants an agent too much functionality, permission, or autonomy, broad tool access, or overly permissive actions, so that a manipulated or malfunctioning agent can take harmful real-world actions rather than simply producing bad text. A business team deploying a multi-agent workflow where one agent can autonomously send emails and another can modify a shared database should treat scoped permissions and a human-approval gate before any high-risk action as essential, not optional. This lesson cross-references ODYSSEY (Adversarial ML and Generative-AI Security, Level III) for the deeper technical treatment of prompt injection, pipeline poisoning, and agentic risk; no prior CCICCS course carried this cross-reference before LOOM (LOOM). References OWASP Foundation (2025). OWASP Top 10 for Large Language Model Applications. https://genai.owasp.org/llm-top-10/ Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/) Responsible AI and Capstone. Bias across the AI lifecycle, privacy, transparency, accountability, and a synthesis capstone. Identify where bias can enter at each stage of the AI lifecycle and propose a mitigation appropriate to that stage. Produce a capstone workflow design that specifies data flow, model choice, evaluation plan, and governance controls for a stated original business scenario. Bias across the AI lifecycle (Barocas and Selbst, 2016), Privacy, Transparency and accountability, Capstone: designing a governed, no-code agentic workflow Module 11. Responsible AI and Capstone Bias across the AI lifecycle Barocas and Selbst's 2016 analysis, "Big Data's Disparate Impact," examined how data-driven decision-making can inadvertently produce discriminatory outcomes even without any explicit intent to discriminate (Barocas & Selbst, 2016). This module treats bias as something that can enter at multiple stages of the AI lifecycle, not just at final deployment: data collection, labeling, feature selection, model training, and the context of deployment itself. A capstone workflow that trains a hiring-screening classifier on a biased historical dataset, without auditing that data for disparate outcomes across groups, risks perpetuating or amplifying that historical bias into the model's future decisions. Privacy, transparency, and accountability Privacy concerns how personal or sensitive data is collected, used, retained, and protected throughout an AI system's lifecycle. Transparency means providing stakeholders with an honest account of how a system works, what it can and cannot do, and the basis for its outputs, not making a system's source code public, but making its behavior and limits legible to the people affected by it. Accountability requires a clear line of responsibility for a system's decisions and outcomes, so that problems can be identified, addressed, and remediated rather than diffused across no one in particular. The capstone The capstone exercise asks the learner to design, justify, and evaluate a complete no-code agentic workflow against an original business scenario, not one drawn from any external program's case studies. At minimum, the design must specify the data flow and no-code tooling choices covered in Modules 1 through 5, the generative and agentic components used from Modules 6 through 10 along with their evaluation plan, and the governance controls addressing bias, privacy, and the agentic-AI-specific risks introduced in Module 10. A submission that proposes an agentic workflow with broad, unscoped tool permissions and no mention of the agentic-AI-security lesson from Module 10 does not meet this course's quality gate, since the standard requires the capstone to integrate the governance and security material covered earlier, not just demonstrate working technical functionality. Reviewing the course's arc from Module 0 to this capstone, the clearest continuity this final module asks learners to identify is that every technique in this course, from clustering through agentic orchestration, carries governance and evaluation obligations that a working no-code workflow must address explicitly. Technical functionality alone was never the standard this course set. References Barocas, S., & Selbst, A. D. (2016). Big Data's Disparate Impact. California Law Review, 104, 671-732. https://doi.org/10.15779/Z38BG31 Related CCI capabilities Computer Architecture (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/computer-architecture/). Optics Primer Series (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/optics/). Maths Refresher Series, Finance (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/maths-finance/). System Dynamics (Course): (https://www.cambridgecyberinternational.com/en/insights/academy/system-dynamics/). CCI Lab: Run it, build with it, read the thinking, reuse the data. (https://www.cambridgecyberinternational.com/en/insights/lab/)