4‐1 Agentic AI concepts - terrytaylorbonn/auxdrone GitHub Wiki

26.0410 Lab notes (Gdrive) Git

This page is a WIP (reorganized 26.0410).

• 1) What is an agent. An agent is (in this wiki a Python) control loop that uses an LLM to decide actions on external data and tools.
• 2) LLM limitations. LLM outputs are inherently unpredictable and cannot be used (by a Python script) directly without safeguards.
• 3) Agent design constraints. Agents enforce strict structure (schemas, validation, deterministic execution) to make LLMs reliable.
• 4) Application design constraints. Agentic AI is only suitable for domains where errors are manageable, outcomes can be controlled/validated, and (most importantly) errors can be tolerated.
• 5) Standard agent loop. Agents operate in a loop: plan with LLM, execute with code and tools, then interpret results.
• 6) Demos. The demos implement variations of the agent loop to illustrate core concepts in practice.
• 7) Substack posts. Informal write-ups exploring ideas, experiments, and evolving perspectives on agentic AI.

An agent is:

• a loop
• that uses an LLM
• to decide actions
• on external tools/data
• under strict control

LLM outputs are unpredictable

• outputs vary for same input
• may break JSON / format
• cannot be trusted directly in code

Agents (typically Python scripts) are deterministic, and therefore must be designed carefully to work reliably with an LLM.

Because LLM outputs are unpredictable, agents must operate inside strict constraints:

• fixed actions
• JSON outputs
• validation
• deterministic execution

To achieve this, the agent focuses on:

• validation
• parsing
• output constraints
• structured data models (ontology / schema)

Even with controlled agent design, not all applications are suitable for agentic AI.

Agentic AI is best used for decision support and automation, not safety-critical control.

Agents are appropriate when:

• errors are low-cost
• outputs can be validated
• actions are reversible or supervised

Agents are NOT appropriate when:

• errors have high physical or safety consequences
• real-time guarantees are required
• full determinism is needed

For example, Safe operation of humanoid robots around people requires strict real-time control and safety guarantees that current LLM-based agents cannot provide.

This leads to the following standard agent loop. All demos are variations of this loop, with different tools and constraints.

1. User input (to the agent) (if there is a user)

2. Agent → LLM (plan request) message includes:

   • ANALYSIS SCHEMA TEXT
   • events_json (for PAL agent)

3. LLM → Agent returns structured plan

4. Agent validates plan
   4b. if invalid → ask LLM to fix

5. Agent executes plan

   • deterministic code execution
   • may call Tools (Gmail/DB) if required

6. Tools → Agent return data

7. Agent → LLM (explain / finalize) sends results + context

8. LLM → Agent returns final response

9. Agent → User (if there is a user)

10. Loop back to step 1

The first demo is the simplest demo that shows the core basics.

These concepts are demonstrated in:
[tie every concept directly to demos]

• AI app basics → output control
• PAL demos → planning + execution
• n8n demos → workflow automation

These are typically quick rough draft posts on various topics. A few examples:

• #72 A simple AI app demo. Deployed on Render.com.
• #68 What is an AI platform? Basically a new iteration of the traditional app/POSIX/OS architecture.