cs.AIMar 16, 2026

Knowledge Activation: AI Skills as the Institutional Knowledge Primitive for Agentic Software Development

Authors: Gal Bakal

Organizations: Yahoo Inc.*

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

Enterprise software organizations accumulate critical institutional knowledge - architectural decisions, deployment procedures, compliance policies, incident playbooks - yet this knowledge remains trapped in formats designed for human interpretation. The bottleneck to effective agentic software development is not model capability but knowledge architecture. When any knowledge consumer - an autonomous AI agent, a newly onboarded engineer, or a senior developer - encounters an enterprise task without institutional context, the result is guesswork, correction cascades, and a disproportionate tax on senior engineers who must manually supply what others cannot infer. This paper introduces Knowledge Activation, a framework that specializes AI Skills - the open standard for agent-consumable knowledge - into structured, governance-aware Atomic Knowledge Units (AKUs) for institutional knowledge delivery. Rather than retrieving documents for interpretation, AKUs deliver action - ready specifications encoding what to do, which tools to use, what constraints to respect, and where to go next - so that agents act correctly and engineers receive institutionally grounded guidance without reconstructing organizational context from scratch. AKUs form a composable knowledge graph that agents traverse at runtime - compressing onboarding, reducing cross - team friction, and eliminating correction cascades. The paper formalizes the resource constraints that make this architecture necessary, specifies the AKU schema and deployment architecture, and grounds long - term maintenance in knowledge commons practice. A Yahoo deployment surveying 67 engineers shows statistically significant developer-experience gains - 2.6 hours per week saved, Net Promoter Score +35. Organizations that architect their institutional knowledge for the agentic era will outperform those that invest solely in model capability.

Figures & tables

Figure 1: The Institutional Impedance Mismatch. A structural disconnect separates what knowledge consumers bring to an enterprise task (left) from what the organization’s institutional knowledge contains (right). Skills (center) bridge the gap by delivering structured, governance-aware institutional knowledge at the point of need—equipping agents to act with institutional accuracy and enabling the engineers working with them to receive organizationally grounded guidance.
Figure 2: The knowledge consumer spectrum. Three classes of knowledge consumer face the same structural deficit—the Institutional Impedance Mismatch—under different constraints: AI agents are bounded by the finite context window, newly onboarded engineers by limited absorptive capacity for institutional knowledge, and cross-team engineers by the time pressure of operating on unfamiliar codebases. Skills serve all three through the same agent-mediated mechanism, delivering institutionally grounded guidance at the point of need.
TermDefinition (Section)
Knowledge ConsumerAny entity—autonomous AI agent, newly onboarded engineer, or cross-team contributor—that must acquire institutional knowledge to act effectively in an enterprise context (§ 1 )
Context Window EconomyThe regime in which knowledge delivery to agents is governed by token budget, attention decay, and latency cost constraints (§ 3 )
Institutional Impedance MismatchThe structural disconnect between a knowledge consumer’s existing knowledge and an organization’s specific institutional patterns (§ 1 )
Last-Mile Problem of Agentic Software DevelopmentThe deployment-side framing of the Institutional Impedance Mismatch: the gap between general foundation-model capability and organization-native agent behavior, closable only by an institutional knowledge architecture (§ 1 , § 8 )
Knowledge ActivationThe three-stage process (codification, compression, injection) transforming latent institutional knowledge into structured, agent-executable form (§ 4 )
Atomic Knowledge Unit (AKU)The minimal self-contained bundle of intent, procedure, tools, metadata, governance, continuations, and validators enabling one coherent action (§ 5 )
Table 1: Key terms introduced in this paper.
Figure 3: Two paradigms for navigating organizational knowledge. In the deterministic paradigm (left), the complete process topology is visible, alternatives are evaluated, and the optimal path is pre-computed before execution begins; the approach works only for situations the designer anticipated. In the situated paradigm (right), the agent operates with local visibility bounded by the context window, traversing the same topology one junction at a time. Green markers represent Skills—locally sufficient knowledge artifacts that provide structured guidance at each decision point. Skills are distributed throughout the topology (faded markers) but become actionable only when the agent reaches each junction.
DimensionHuman DeveloperLLM-Based Agent
Access modelIterative search and browseSingle-shot context injection
CapacityEffectively unbounded (over time)Fixed token window per invocation
AttentionSelective, self-directedPositional, architecture-dependent
PersistenceLong-term memory across sessionsStateless across invocations (by default)
Format toleranceHandles ambiguity, formatting noiseSensitive to token waste, irrelevant content
Feedback loopCan ask clarifying questions in real timeMust act on context as given
Table 2: Knowledge consumption patterns: human developers versus LLM-based agents.
Figure 4: The Context Rot Cycle. When an agent lacks institutional knowledge, it enters a vicious cycle of guess, failure, correction, and retry. Each iteration fills the context window with detritus, degrading effective reasoning capacity. Knowledge Activation breaks the cycle by delivering pre-structured institutional knowledge upfront.
DimensionKnowledge Retrieval (RAG)Knowledge Activation
Unit of deliveryDocument chunk (passage)Atomic Knowledge Unit (skill)
Content typeInformational textAction-ready specification
Tool integrationAbsent; model must infer toolsExplicit tool bindings included
GovernanceNot encodedEmbedded constraints and permissions
Organizational contextMinimal or absentOwnership, service catalog, team metadata
Optimization targetRelevance to queryValue per token for task completion
Table 3: Knowledge Retrieval versus Knowledge Activation.
Figure 5: Knowledge Retrieval versus Knowledge Activation: architectural comparison. In retrieval-based approaches (left), the agent receives unstructured text fragments and must interpret, plan, infer tools, and determine governance constraints at runtime. In Knowledge Activation (right), the agent receives a pre-structured Atomic Knowledge Unit and acts according to the specification. The interpretation burden shifts from runtime inference to knowledge authoring.
Figure 6: The Knowledge Activation Pipeline transforms latent organizational knowledge through three stages: Codification captures institutional knowledge from experts, runbooks, APIs, and policies; Compression distills it into token-efficient Atomic Knowledge Units that maximize knowledge density ρ(k,τ)\rho(k,\tau) ; Injection delivers the appropriate AKU at the point of need, equipping the agent to act with institutional accuracy or to surface the information and approval requests that require human judgment.
ComponentPurpose
Intent DeclarationSpecifies what the skill accomplishes and under what conditions it should be activated
Procedural KnowledgeProvides step-by-step guidance, constraints, patterns, and anti-patterns for execution
Tool BindingsIdentifies which tools, APIs, or platform capabilities the agent should invoke
Organizational MetadataEncodes team ownership, service catalog references, and environment-specific context
Governance ConstraintsDefines permission boundaries, approval workflows, and blast radius limits
Continuation PathsSpecifies what to do next: related skills, escalation paths, and fallback strategies
Table 4: The seven components of the Skill schema.
Figure 7: The interoperable skill network. Skills are not isolated artifacts but nodes in a self-navigating process graph. Each skill’s continuation metadata encodes routing to neighboring skills: solid arrows represent success continuations, dashed arrows represent failure continuations, and dotted lines represent escalation to human operators. The blue dot indicates the agent’s current position. The routing intelligence is distributed across the network—each skill knows its neighbors—enabling structured iteration without a central orchestrator and preventing context rot by ensuring that failure reaches a known junction with structured guidance rather than a context-free retry.
Figure 8: The seven-component Skill schema. Each Skill bundles intent, procedural knowledge, and tool bindings (the “how”) with organizational metadata, governance constraints, validators, and continuation paths (the “where, who, and what next”), forming a composable Atomic Knowledge Unit.
DimensionSkill (AKU)RunbookSOPAnsible PlaybookBackstage Template
Intent declarationMachine-matchable triggerTitle/summaryTitle/scopePlay nameTemplate name
Procedural knowledgeToken-optimized for agentProse for humansProse for humansDeclarative YAMLScaffolding steps
Tool bindingsExplicit, typedImplicit or absentAbsentBuilt-in modulesPlugin hooks
Org. metadataTeam, tier, SLA, catalogVariesVariesInventory groupsCatalog entity
GovernanceEmbedded constraintsAbsentApproval gatesLimited (tags)Absent
ValidatorsDeterministic scriptsAbsentAbsentHandlers (partial)Absent
Table 5: Skills compared to existing knowledge and automation artifacts.
Figure 9: Abbreviated example of a “Deploy Microservice” skill illustrating all seven schema components.
Figure 10: Abbreviated example of a “Respond to Production Incident” skill, demonstrating the schema’s applicability beyond deployment workflows.
Figure 11: The three-layer Agent Knowledge Architecture. The AKU Registry provides a queryable catalog of Atomic Knowledge Units; the Knowledge Topology captures relationships between AKUs (dependencies, sequences, alternatives); the Activation Policy governs which AKUs are available to which agents under which conditions.
Figure 12: The Governance Gradient. Skills are positioned along a continuous spectrum from fully autonomous to fully human-controlled operation, determined by validator coverage, permission scope, and historical execution record. Over time, skills migrate toward greater autonomy as validator coverage increases and successful execution records accumulate.
Driver dimensionTop-boxMean (95% CI)Cohen’s ddEffect size
Reduced mental effort (Q6)75%4.05 (3.81–4.29)1.40Very large
Flow preservation (Q7)72%3.87 (3.55–4.19)0.89Large
Surfaces requirements (Q8)67%3.72 (3.46–3.98)0.91Large
First-try compliance (Q9)66%3.79 (3.52–4.06)0.97Large
Table 6: Developer experience driver findings. Top-box is the proportion of respondents selecting “agree” or “strongly agree”; mean is on a 5-point Likert scale (neutral =3=3 ). One-sample tt -tests against the neutral midpoint, p<0.0001p<0.0001 for all four drivers; degrees of freedom range from 37 to 39 due to optional-question skip patterns. Effect sizes follow Cohen’s conventions with “very large” applied to d>1.2d>1.2 .
Figure 13: The knowledge commons governance model. Technical governance (bottom) uses validators to ensure skills execute correctly. Social governance (top) uses an InnerSource contribution model to ensure skills remain accurate as organizational practices evolve. The platform team stewards both layers, governing the topology and activation policies rather than authoring every skill. Technical governance catches execution failures; social governance catches conceptual drift—the case where a skill runs successfully but no longer reflects how the organization actually works.

Explore similar work

CardsList
Apr 13, 2026

Context Kubernetes: Declarative Orchestration of Enterprise Knowledge for Agentic AI Systems

We introduce Context Kubernetes, an architecture for orchestrating enterprise knowledge in agentic AI systems, with a prototype implementation and eight experiments. The core observation is that delivering the right knowledge, to the right agent, with the right permissions, at the right freshness -- across an entire organization -- is structurally analogous to the container orchestration problem Kubernetes solved a decade ago. We formalize six core abstractions, a YAML-based declarative manifest for knowledge-architecture-as-code, a reconciliation loop, and a three-tier agent permission model where agent authority is always a strict subset of human authority. On synthetic seed data, we compare four governance baselines of increasing strength: ungoverned RAG, ACL-filtered retrieval, RBAC-aware routing, and the full architecture. Each layer contributes a different capability: ACL filtering eliminates cross-domain leaks, intent routing reduces noise by 19 percentage points, and only the three-tier model blocks all five tested attack scenarios -- the one attack RBAC misses is an agent sending confidential pricing via email, which RBAC cannot distinguish from ordinary email. TLA+ model-checking verifies safety properties across 4.6 million reachable states with zero violations. A survey of four major platforms (Microsoft, Salesforce, AWS, Google) documents that none architecturally isolates agent approval channels. We identify four properties that make context orchestration harder than container orchestration, and argue these make the solution more valuable.

Charafeddine Mouzouni

OPIT – Open Institute of Technology, and Cohorte AI, Paris, France.

AI Agent GovernanceLLM Context ManagementLLM Agent OrchestrationAI Agent Security
AskPDF
Jul 27, 2026

Authoring Agent Skills: A Software-Engineering Approach

Agent Skills are an emerging way to extend large language model agents with reusable procedural knowledge that the agent loads on demand. Anthropic introduced Agent Skills and published the format as an open specification supported across several agent tools. This note argues that a skill is a software artefact and that its construction should follow software-engineering principles, with qualifications: single responsibility, separation of interface from implementation, low coupling, and economy in a shared token budget, together with behavioural evaluation in place of deterministic testing. Using Claude Code as the reference implementation, it describes how a skill is structured, how its contents are loaded in stages, and how to write the description on which selection depends. It places skills against the other mechanisms a developer can use to shape agent behaviour, like project memory files, slash commands, subagents, external tool connections, and hooks, and gives a rule for choosing between them based on who decides that a mechanism runs and what guarantee it provides. It then sets out an evaluation-driven authoring process, a set of patterns and faults commonly encountered in authoring, and the trust question raised by using skills from third parties. We illustrate the comparison drawn in UML class style, the loading model, the anatomy of a skill, the relative position of each mechanism, and the points at which skills and hooks act during a session.

Giuseppe Destefanis

Department of Computer Science, University College London

LLM Agents
AskPDF
Feb 24, 2026

SoK: Agentic Skills -- Beyond Tool Use in LLM Agents

Agentic systems increasingly rely on reusable procedural capabilities, a.k.a., agentic skills, to execute long-horizon workflows reliably. These capabilities are callable modules that package procedural knowledge with explicit applicability conditions, execution policies, termination criteria, and reusable interfaces. Unlike one-off plans or atomic tool calls, skills operate (and often do well) across tasks. This paper maps the skill layer across the full lifecycle (discovery, practice, distillation, storage, composition, evaluation, and update) and introduces two complementary taxonomies. The first is a system-level set of seven design patterns capturing how skills are packaged and executed in practice, from metadata-driven progressive disclosure and executable code skills to self-evolving libraries and marketplace distribution. The second is an orthogonal \textbf{representation ×\times scope} taxonomy describing what skills are (natural language, code, policy, hybrid) and what environments they operate over (web, OS, software engineering, robotics). We analyze the security and governance implications of skill-based agents, covering supply-chain risks, prompt injection via skill payloads, and trust-tiered execution, grounded by a case study of the ClawHavoc campaign in which nearly 1{,}200 malicious skills infiltrated a major agent marketplace, exfiltrating API keys, cryptocurrency wallets, and browser credentials at scale. We further survey deterministic evaluation approaches, anchored by recent benchmark evidence that curated skills can substantially improve agent success rates while self-generated skills may degrade them. We conclude with open challenges toward robust, verifiable, and certifiable skills for real-world autonomous agents.

Yanna Jiang, Delong Li, Haiyu Deng +4

University of Technology Sydney · CSIRO Data61

Agentic AILLM Agent Skill LearningLLM Agent Security
AskPDF