Cisco AI Technical Practitioner

Where a model runs shapes cost, speed and privacy. You compare cloud-hosted services with local and open-weight models, weigh size against latency, and decide between prompting, retrieval and customizing a model.

• Cloud services and local models compared
• Open-weight and proprietary models
• Model size, cost and latency trade-offs
• Privacy and data location as a deciding factor
• Prompting, retrieval or fine-tuning: choosing
• Running a small model on your own machine

You build A written recommendation for hosting a model for one team use case.

Models only know what is in front of them. You learn how text becomes tokens, how a context window caps what a model can use, and how embeddings and retrieval-augmented generation bring in the right documents.

• Tokens and how text is split
• Context windows and token limits
• What happens when a prompt is too long
• Embeddings and similarity search
• Retrieval-augmented generation step by step
• Chunking documents sensibly

You build A small retrieval setup that answers questions from a set of internal documents.

A good prompt is a specification. You practice zero-shot and few-shot prompting, system and role instructions, structured output, and chaining prompts so each step does one job.

• Clear instructions, context and constraints
• Zero-shot and few-shot prompting
• System prompts and role instructions
• Asking for structured output
• Chaining prompts into a sequence
• Iterating on a prompt with evidence

You build A tested prompt library for five recurring tasks at work.

Models can be tricked and can be wrong with confidence. You learn how direct and indirect prompt injection work, how to limit their reach, and which habits catch fabricated facts before they spread.

• Direct and indirect prompt injection
• Jailbreaks and instruction hijacking
• Separating trusted instructions from untrusted data
• Why models hallucinate
• Grounding answers in sources
• Verifying output before you act on it

You build A set of attack prompts and the fixes that stop each one.

AI reflects its data and its users. You see where bias comes from, how fairness is judged, how generated content can mislead, and what transparency and accountability look like for a team that uses AI.

• Sources of bias in data and models
• Fairness measures and their trade-offs
• Misinformation and synthetic media
• Transparency and explaining AI-assisted decisions
• Accountability for what AI produces

You build A bias review of one AI-assisted process, with the fixes proposed.

Staff paste company data into tools faster than policy can follow. You cover data privacy and exposure, unapproved tool use, threats aimed at AI systems, and the policies and governance frameworks a team needs.

• What data must never reach an external model
• Shadow AI and unapproved tools
• Data poisoning, model theft and other AI threats
• Acceptable use policy for AI
• Governance roles and review processes
• Frameworks such as the NIST AI Risk Management Framework

You build An AI acceptable use policy for a team, with a data handling table.

AI can speed up the first pass over data and sources. You use it for exploratory analysis, cleaning and reshaping data, and summarizing research, with controls that keep sensitive data out and results checked.

• Exploratory analysis with an AI assistant
• Cleaning and reshaping data
• Summarizing and comparing sources
• Checking AI-produced numbers and citations
• Masking or removing sensitive fields first
• Documenting how a result was produced

You build A short research brief produced with AI and checked line by line.

Code assistants change how software gets written. You generate and explain code, prototype quickly, write tests with AI help, watch token costs, and run quality checks so generated code earns its place.

• Generating code from a clear specification
• Explaining and refactoring existing code
• Prototyping an idea quickly
• Generating tests and documentation
• Token costs and keeping them in check
• Reviewing generated code for quality and security

You build A working prototype built with AI help, reviewed and tested before use.

Single prompts become useful when joined into a process. You map a business task into steps, decide which steps AI should do, add review points, and measure whether the workflow beats the manual one.

• Breaking a task into steps
• Deciding which steps suit AI
• Triggers, inputs and outputs
• Quality gates and human review
• Measuring time saved and errors introduced

You build A workflow diagram and working draft of one automated business process.

Agents act, not just answer. You tell agentic use from generative use, design an agent around a goal, tools and memory, and judge how much freedom a given task should get.

• Generative against agentic: the difference
• Goals, tools, memory and the agent loop
• Single agents and multi-agent designs
• Orchestration of several steps or agents
• Choosing a level of autonomy
• Common agent failures

You build A design for one agent, with its goal, tools and limits written out.

Agents need safe access to tools and people who stay in charge. You learn the primitives of the Model Context Protocol, how it connects a model to tools and data, and where a human must approve or take over.

• What MCP standardizes and why
• Tools, resources and prompts as MCP primitives
• Connecting an agent to an MCP server
• Approval steps and human-in-the-loop designs
• Logging and reviewing what an agent did

You build An agent connected to one tool through MCP, with an approval step before it acts.

Combine model choice, prompting, security and oversight into one design. You choose the model, build the workflow, defend it against misuse, set the controls and present it to colleagues as something they can trust.

• Choosing a problem and a model
• Building the workflow with prompts and retrieval
• Testing for injection, errors and bias
• Setting data controls and approval points
• Presenting the design and its limits

You build A documented AI workflow for a real team task, with tests, controls and an owner.