QS

This page (WIP) describes a set of start-to-finish demos that teach the core concepts of AI.

TOC

• 2 NN demos. Tiny demos that can also run on a CPU. These NNs only know FP numbers as input and output. So if you have any type of other data, you must encode and then decode.
• 2b Model demos. A model contains the NN/CNN/TF and an “internal” agent (iAgent) that controls and provides access to the NN/CNN/TF. The iAgent implements an API that provides external access to the model.
• 3 External agent (py script) demos. Using a model as a helpful assistant.
• 3b Project demos. Projects are where all the previous pieces come together. They aren’t just “more demos” — they’re the integration point. The real goal of AI projects is to integrate AI into an existing SW app. However, there are no such “integration” apps yet… but the following are good initial demos:

Master diagram (ZAI original)

Note: Old demos are available on Wiki, Github, Gdrive (docx lab notes).

GPT:
Overall, I think this is one of the strongest organizational ideas you've come up with. It answers the question that every newcomer has:
"What should I actually build first?"
Your site has become large enough that people need a guided path. A QS page solves that.
(1) The basic idea
I would score it 9.5/10.
The only thing I'd change is the philosophy.
Instead of
•	"one demo from each section"
I'd make it
•	"one representative demo that teaches the core idea of that section."
That is a subtle but important distinction.
For example, D4 isn't chosen because it's "the CNN demo."
It's chosen because it teaches almost everything someone needs to know about CNNs.

2 NN demos

Tiny demos that can also run on a CPU.

• 2.1.2 Tiny NN (very basic NN).
• 2.2.1 Tiny CNN (very basic CNN for recognizing digits 0-9).
• 2.3.6.1 Tiny transformer (very basic TF that outputs “hello world…” for input “h”).
• 2.5 Tiny Robotic NN (very basic demo of using NN to avoid obstacles).

2.1.2 Tiny NN / demo D2ccc

This one simple NN demo will give you an understanding of the core of all AI inference (including CNNs, LLMs TFs, etc). The following diagram shows the core components of the demo:

• Encoder. All NNs only “know” numbers (including ChatGPT, Claude, etc). So if you have a dataset that is not (FP) numbers, it must be encoded (and later decoded).
• NN. The source of “intelligence”. A UFA (universal function approximator).
  • This NN inputs 2 numbers. And based on that number outputs 2 probabilities. That’s it.
• Decoder. Convert from a probability for inside/outside the circle to a binary state (1 or 0; inside/outside circle).

GPT: It teaches tensors, forward(), Linear, ReLU, logits, CrossEntropy, training, inference without overwhelming people.*

2.2 Tiny CNN demo D4 MNIST

A hands on demo. Input a 28x28 pixel screenshot of a digit, and the NN outputs “0”, “1”, … “9”. See also 2.2.1b D4 CNN algorithm details.

There are 3 main parts.

• 1 Data input. In this case the data input is ………….
• 2 Feature extraction (nn.Conv2d + nn.MaxPool2d). This is where convolution and pooling are used to turn the original pixel values into “hidden state” values that progressive define higher level features (I typical call these values “pix’s”). …
• 3 Final NN (nn.Linear) computing CNN “logits”. This involves
  • 3.1 Linear NN (like for D2ccc) computes the probabilities of each of 10 possible outputs (digits 0 to 9).
  • 3.2 The most probable output is converted into a label (such as “7”). –>

CNN demo D4 overview (ZAI/GPT original diagram)

2.3.6.1 Tiny TF demo D5

TF demo D5 overview (ZAI original diagram)

2.5 Tiny Robotic NN (wiki)

GPT: 
Tiny obstacle detector (or whichever demo first connects perception to action). 
The important concept isn't robotics hardware. It's sensor → NN → decision → actuator.

ME: i think D30 (28bbb) is the robotic AI demo you mentioned. 
#502_3_robotics_AI_no_jepa_v31_26.0131.docx
28bbb D30 add GIF (BINGO) #174 is there any way to create a gif with just the resulting path and obstacle? 
Yep — very easy, and this is a good next step because visualizing the trajectory is what makes D30 click for robotics readers. 
There are three simple ways, depending on how fancy you want it:

GPT: 
Yes — D30 / 28bbb “avoid the rock” is probably the right 2.5 Robotic AI QS demo.
It has the key robotics loop:
start position
→ perceive obstacle
→ plan path
→ avoid obstacle
→ reach goal
→ visualize trajectory
That is much better than a drone-specific demo for QS, because it is simple, visual, and general.
For QS I’d write:
- **2.5 Robotic AI**. Connects AI to action: perceive the world, choose a path, avoid an obstacle, and move toward a goal. **Demo is D30 “avoid the rock” / 28bbb GIF**.
Why it works:
  “rock” makes the problem intuitive.
  the GIF makes the result instantly understandable.
  it shows robotics without requiring robot hardware.
  it connects perception + planning + action, which is the core idea.
So yes: D30 28bbb is the pick.

2b Model demos

A model contains the NN/CNN/TF and an “internal” agent (iAgent) that controls and provides access to the NN/CNN/TF. The iAgent implements an API that provides external access to the model.

• 2b.2 Tiny demos.
• 2b.2b Building models.
• 2b.3 Modifying models.
• 2b.4 Running models locally.

2b.2 Tiny demos

GPT: M01 (save model) because it introduces NN + .pt.

2b.2b Building models

GPT: M06 HuggingFace publish because suddenly the model becomes portable.

2b.3 Modifying models

GPT: A tiny fine-tuning demo would be excellent
For example: M08 Tiny Fine Tune
  1. Load M01 model.pt, 2. Run inference, 
  3. Continue training for 100 epochs on slightly different data
  4. Save model_v2.pt, 5. Compare outputs before/after
This would teach the core idea:
  Fine-tuning = continue training an existing model on additional data.
  No transformers required. The exact same concept applies to LLMs, just at a much larger scale.
I actually think this would become one of the best demos in your 2b Models section because it bridges the gap between:
  training from scratch (Section 2), and
  using pre-trained models (Section 2b).
So yes—I would make Tiny Fine Tune the representative demo for 2b.3 Modifying models. It fits the section much better than the backdoor example.

2b.4 Running models locally

GPT1: M07 FastAPI. This is where the model becomes a service. 
I think that's exactly what people need to understand

GPT2: Yes. I actually think Ollama is a better representative demo for 2b.4 Running models locally than M07 FastAPI.
The purpose of 2b.4 is not to teach FastAPI. It's to teach:
"How do I run a model on my own computer?"
Most people today will use something like:   Ollama, LM Studio, vLLM,   llama.cpp
rather than writing their own FastAPI server.

3 External Agent demos

The focus of this sections is the actual agents.

3.1 Code-first (no AI). Most of the demos start out without AI to verify.

3.2 Frameworks (no AI / automation). These are designed for any application, whether it uses AI or not. Examples: n8n, FastAPI, Flask, Django, Express.js, Spring Boot. One the best demos would be the n8n demo. The test things about n8n is you can run it easily locally (for free). n8n is not AI-only. Originally it was built as a workflow automation platform. For example: Gmail ↓ Save attachment ↓ Dropbox ↓ Send Slack message. No AI involved.

3.3 Code-first (AI-assisted). The PAL/PAL_CORE demos.

3.4 AI Frameworks. These are specifically designed to make building AI applications easier. Examples: n8n (general automation, but now widely used for AI workflows). Gmail ↓ LLM summarizes email ↓ Store in MongoDB ↓ Mattermost alert. Other examples: LangChain, LangGraph, CrewAI, OpenAI Agents SDK, PydanticAI. These assume that one or more models/LLMs are part of the application. Note that LangChain, CrewAI, etc don’t provide much value without AI. Their purpose is to orchestrate AI models, tools, memory, and workflows.

3 External agent ecosystem

3b Project demos (the end goal of ZiptieAI)

See “Concepts” for an explanation of S1-S4.

PART 1: Enterprise SW demos

The real goal of AI projects is to integrate AI into an existing SW (ESW) app.

• 3b.11 SLACK
  • S1 Simply use the browser to access Slack.
  • S2a Claude + MCP → Slack ✅ (current demo).
  • S2b Claude Tag in Slack ✅ (future demo after Claude gives acccess to the tag function my subscription class). This would be an S2 Native/Managed AI.
  • S3 Slack app + OpenAI. Agent works as a Slack App / Bot (uses Slack APIs / users interact via Slack UI).

3b Slack Project demo ecosystem for stages S1-S4 (S4 add DB?)

Part 2: Standalone AI Application demos.

• 3b.3 NMAP Security Assistant. Uses the local PC as the target system. S4 External AI agent / works OUTSIDE the target.
• 3b.2 GMAIL (JobRadar). Standalone that happens to access Gmail API. Existing system > Gmail > External Agent > LLM > Summary / Alert.

3b standalone AI app (S4 only)

26.0628 (v1 26.0527)