English for Semantic Kernel Developers

Semantic Kernel conversations often involve explaining how the framework connects language model calls to existing application code, so the vocabulary covers plugins, functions, and the planning mechanism that lets a model decide which capabilities to invoke.

Key Vocabulary

Kernel — the central orchestration object in Semantic Kernel that holds registered plugins, connects to configured AI services, and executes functions, acting as the runtime through which all model interactions pass. “Register that plugin on the kernel once at startup — you shouldn’t be constructing a new kernel instance every time you want to call a function.”

Plugin — a collection of related functions (native code or prompt templates) grouped together and exposed to the model as callable capabilities, similar in spirit to a toolset. “Group these three functions into a single plugin — right now they’re registered separately, which makes it harder for the model to discover them as a related set.”

Native function vs. semantic function — Semantic Kernel’s distinction between a function implemented as ordinary code (native) and one implemented as a prompt template interpreted by the model (semantic), both callable the same way by the kernel. “This doesn’t need to be a semantic function — it’s pure arithmetic, so a native function is faster, cheaper, and more reliable than asking the model to compute it.”

Planner — a component that takes a natural-language goal and automatically composes a sequence of registered plugin functions to achieve it, rather than requiring the calling code to hard-code the function call order. “Instead of hard-coding this three-step workflow, let the planner figure out the function sequence — it can adapt if we add or remove plugins later.”

Memory connector — Semantic Kernel’s abstraction for storing and retrieving embeddings from a vector store, used to give the model access to relevant context beyond its immediate prompt. “Wire this up through the memory connector instead of stuffing the entire document into the prompt — then we only retrieve the chunks that are actually relevant to the question.”

Common Phrases

• “Is this function registered on the kernel, or is that why the model can’t see it as an available capability?”
• “Should these functions be grouped into one plugin, or are they unrelated enough to stay separate?”
• “Does this really need to be a semantic function, or would a native function be more reliable here?”
• “Are we hard-coding this sequence, or letting the planner determine the function order dynamically?”
• “Is retrieval going through the memory connector, or are we just dumping raw text into the prompt?”

Example Sentences

Explaining an architecture decision: “We’re using a native function for the calculation and a semantic function only for the summary — no reason to route deterministic logic through the model.”

Reviewing plugin design: “These functions belong in the same plugin — grouping them makes it clearer to the model, and to future developers, that they’re a related capability set.”

Discussing reliability concerns: “Hard-coding the function sequence is more predictable than relying on the planner here — I’d only use the planner where the steps genuinely need to vary by input.”

Professional Tips

• Register capabilities on the kernel at startup rather than per-call — it avoids redundant setup and keeps the model’s available functions consistent across requests.
• Group related functions into a single plugin to make the capability set more discoverable, both to the model and to developers reading the code.
• Default to native functions for anything deterministic — save semantic functions for genuinely language-dependent tasks like summarization or classification.
• Reserve the planner for workflows where the step sequence genuinely needs to vary — hard-coded sequences are more predictable and easier to debug for fixed workflows.

Practice Exercise

1. Explain the difference between a native function and a semantic function, with an example of when you’d choose each.
2. Describe what a plugin groups together and why grouping matters for model discoverability.
3. Write a sentence explaining to a teammate when you would use the planner instead of hard-coding a function sequence.