Category Archives: artificial-intelligence

Kano Model and the AI Agentic Layers

Quick Refresher on the Kano model

Kano Category	What it mean and why it matters
Must-have (Basic)	Expected capability; absence of it causes failure, presence of it does not delight
Performance	Better Execution = more value
Delighters	Unexpected differentiation creates step-function value
Indifferent	no material impacts on outcomes
Reverse	Actively reduces value or trust

7 Layers of Agentic AI

My definition of the 7 layers of Agentic AI are as follows:

Agentic AI Layer	What it means
Experience and Orchestration	Integrates agents into human workflows, decision loops, and customer experiences. This is the business layer. Help accelerate decision-making. Decide when to override agents, e.g., an automated agent taking in returns from customers and deciding which returned merchandise deserves a refund and which does not.
Security and compliance	This is the most important layer, in my opinion. This makes sure that agents do not run wild in your organization. The right level of scope and agency is given to your generative AI agent. Includes policy engines, audit logs, Identity and role-based access, and data residency requirements.
Evals and Observability	The basis of explainable AI. It creates confidence in the outputs that the agent will generate. Agents operate in a non-deterministic way. Your tests must reflect non-deterministic reality to engender trust and reflect the proper upper and lower bounds of such non-determinism. This includes telemetry, scenario based evals, Outcome based metrics, Feedback loops etc.
Infrastructure	This layer makes agents reliable, scalable, observable, and cost controlled. Without this layer, AI pilots cease to be platforms.
Agent Frameworks	Transforms AI into a goal-directed system that can plan, decide, and act. This includes memory, task decomposition, state management, and multi-agent coordination patterns, to name a few.
Data Operations	Key elements of your agentic experience, data quality, freshness, data pipeline scale, etc., are all relevant here. This includes RAG, vector databases, etc.
Foundation models	The operating system of the Agentic experience that we are trying to develop

Mapping the 7 layers to Kano Value

Layer 1: Foundation Model

Primary Kano Category: Must have $->$ Indifferent

Foundation models are now considered a standard expectation; possessing the latest GPT model is no longer a distinguishing factor. However, the absence of such technology can lead to negative consequences from your users.

Hence,

The foundation model presence does not mean differentiation
Absence means immediate failure
Overinvestment in this space yields diminishing returns

Anti-Patterns

The anti-pattern for this value is when the model is the strategy. This fails on so many fronts due to the following:

First, one must identify a model and subsequently determine a problem to address.
- This is analogous to selecting a car model prior to establishing the destination and the nature of the terrain to be navigated.
Treating Foundation model benchmark scores as business value
- If you are driving on the rocks of Moab, Utah, having a 500-horsepower vehicle is not helpful
Hard-wiring a single model to the system
- hitching your business to a single model and not having any leverage
Ignoring latency and cost variability
- For the outcomes you want, do know that the cost variations you are willing to tolerate
Assuming newer is better
- Does the newer model of the vehicle support the terrain on which you want to drive in.

Smell test

“If we change the models tomorrow, does the product still work?”

Layer 2: Data Operations

Primary Kano Category: Performance

Good data means relevant decisions, outcomes, and outputs. The critical elements here are:

Accuracy
Trust
Decision Quality

Users can feel the data is bad, even if they do not know why.

The value in this space is linear with quality improvements and when there is a strong correlation to business outcomes. Like any good system, it is invisible when everything is working well and painful when broken. Poor data becomes a Reverse feature (hallucinations, mistrust)

Anti-Patterns

Dumping entire knowledge bases into embeddings
- This is generally a common thought process that prevails in most organization when adopting AI
No freshness or versioning guarantees
- Something hallucinates; it is usually because of the data.
Ignoring access control in retrieval
- This is common in most cases Agents have unfettered access to data, which is quite problematic for the business overall
Treating RAG as a one-time setup
- This needs to be validated in regular intervals, as the business terrain may change
No measurement of retrieval quality
- “Let us all trust AI blindly” is never a successful strategy

Smell test

“Can we explain why the agent used this data”

Layer 3: Agent Frameworks

Primary Kano Category: Performance $->$ Delighter (Conditional)

Agents that can plan, act, and coordinate unlock:

Automation
Decision delegation
Speed at Scale

These gains can only be realized with the right context windows and when constrained correctly; that is when the actual performance gains are achieved. Remember, agents are logical machines; they are neither credible nor emotional, which does make working with them challenging.

The mantra of starting simple and then focus on scale really does help here.

Anti-Patterns

Starting with multi-agents systems
- If you do not have the basics right and multi-agent systems will compound the problem exponentially
No explicit goals or stopping conditions
- Agents being unbounded means more risk to the business as the probability field is wider
Optimizing for activity, not the outcome
- An agent denied a $5 return to a customer, this activity was done right, but the customer, who had a positive lifetime value over the last five years, churned because of the bad experience

Smell Test

“Can we explain what the agent is trying to achieve in one sentence?”

Layer 4: Deployment & Infrastructure

Primary Kano Category: Must-Have

No user ever says, “I love how scalable your agent infrastructure is.” . But they will leave when the agent fails to scale. This layer is the bedrock of all your agentic experience and has zero visible upside but has several downsides when ignored. This is just like cloud reliability in the early cloud days.

Anti-Patterns

Running agents without isolation
- Agents can consume a lot of resources and become expensive very quickly. This is not just tokens, but also compute, storage, networking, and security; i.e., all of it.
Not having any rate limits or quotas
- Goes back to the prior statement; please have your agents bonded. Not having any cost attribution is another challenge, and it is not amortized across your product portfolio.
Scaling pilots directly to production
- This is when a small signal seems good enough for production, and then hell breaks loose. The cost of failure in production is high; please respect that and make sure to have all the appropriate checks and balances in place as you deploy these agents.

Smell Test

“What happens if this agent runs 100x more often tomorrow?”

Layer 5: Evaluations & Observability

Primary Kano Category: Performance $->$ Delighter (for Leaders)

Customers may not notice evals, but executives, regulators, and boards do. This layer enables faster iteration, risk-adjusted scaling, and organizational trust. The learning curve accelerates, increasing deployment velocity, and the side effect of all this is less fear-driven decision-making.

This area is important since once we get from the demo stage to the production stage, having explainable AI demonstrates a lot of value.

Anti-Patterns

Static test cases in dynamic environments
- Check out my blog on Dynamic Evaluations. Although it talks about it in the context of security, it holds true in several cases, such as predictive maintenance of robots in an assembly line.
Measuring accuracy instead of outcomes
- This is a trap we all fall into, because we come from a deterministic mindset and we need to move to probabilistic.
No baseline comparisons
- Having some sort of a reference of something to understand the potential probability spread
No production monitoring
- Monitoring production is the most important thing in AI; please do not ignore it
Ignore edge cases and long-tail failure
- AI is probabilistic, so the probability of hitting an edge case is a lot higher than a deterministic system with a happy path. Please prepare for it.

Smell Test

“How do we know the agent is getting better or worse?”

Layer 6: Security and Compliance

Primary Kano Category: Must have $->$ Reverse if Wrong

This is another layer of the unsung hero, and is what makes news headlines when an agent compromises an organization. Agentic AI failures are public, hard to explain, and non-deterministic. Just like the data and infrastructure layer, there is no upside for security, but unlimited downside if you do not have security. If you are addressing the needs of the regulated market, this is an area that you need to focus on… a lot.

Security is the price of admission for enterprise systems; if you are not ready to pay it… then I would highly recommend that you do not play in this space.

Anti-Patterns

Relying on prompt instructions for safety
- The same prompts that you rely on for safety can be used to compromise your security posture
No audit logs
- Just like you need to know which user did what, the need is even more when a non-person entity has agency
No agent identity
- Just like users agents need an identity, and user context awareness. The latter is needed to make sure agents identities honor the scope of the initial user that made the request
Over restrictions on agents to point of uselessness
- You need to have an objective in mind and plan your security accordingly otherwise, the system becomes useless and is unable to support any decision making
Treating agents like deterministic API
- Yes, even though we have Model Context Protocol, that does not mean have a determinstic system. The host still has to understand the data returned by the MCP server to deliver a probabalistic answer to the user who provided the initial context

Smell Test

“Can we prove what this agent did, and why?”

Layer 7: Agentic Experience and Orchestration

Primary Kano Category: Delighter

This layer captivates users, prompting remarks such as, “I can’t go back to my old way of working.” It transforms workflows, enhances customer experience, and accelerates decision-making. A strong adoption pull and non-linear ROI characterize this phase. Here, differentiation truly takes shape, as all the hard work invested in data, infrastructure, and security compliance pays off, making it increasingly difficult for competitors to replicate your success. Therefore, it is crucial to carefully manage the data you expose to other agentic systems; otherwise, your differentiation may be short-lived.

Anti-Patterns

Assuming that chat serves as the sole interface for AI agents can be misleading.
- AI agents encompass various forms, including workflows and content aggregators. While the chat interface represents one of several manifestations, natural language input does not necessitate that chat be the primary interaction method.
Removing human checkpoints too early in the process
- Reinforcement learning in the context of the business domain, can happen with help of humans. Just because agentic storage systems has ingested a lot of data does not mean it is business domain savvy
Ignoring change management
- when you iterating fast you need to make sure that you have the appropriate fall back measures. Otherwise it is like watching a trainwreck
Measuring usage versus impact
- With Web applications, usage meant that users were engaging with the system, with agents especially with multi-agent environment it is not usage but the impact of the agents to the business and the value it accelerates. This is where outcomes becomes even more imperative, it also the building block for outcome based pricing in the future

Smell Test

“Does this help people decide faster or just differently?”

Bring it all together

Layer	Kano Category	Value Signal	Risk if ignored
7. Experience and Orchestration	Delighter	Step-function ROI	No Adoption
6. Security & Compliance	Must-Have	Market Access	Existential Risk
5. Evals and Observability	Performance/Delighter	Faster scaling	Loss of trust
4. Infrastructure	Must-Have	Reliability	Cost & Outages
3. Agent Frameworks	Peformance	Automation gains	Chaos
2. Data Operations	Performance	Accuracy & trust	Hallucinations
1. Foundation Models	Must-Have	Baseline capability	Irrelevance

It is very easy to fall into the trap of focusing just on the delighers (Layer 7) , while underfunding the must haves (Layers 4 – 6). When you do that your results of your AI agentic pilots look like this:

Flashy demos
Pilot Purgatory
Security Vetoes
Executive Distrust

They way Agentic AI moves from experimentation $->$ ROI $->$ Tranformation is :

Fund bottom layers for safety and speed
Differentiate at the top
Measure relentlessly in the middle.

Measuring What Matters: Dynamic Evaluation for Autonomous Security Agents

1 Reply

This week’s blog title pays tribute to one of my preferred books, “Measure What Matters” by John Doerr. In my earlier post, I briefly addressed the concept of dynamic evaluations for agents. This topic resonates with me because of my professional experience in application lifecycle management. I have also worked with cloud orchestration, cloud security, and low-code application development. There is a clear necessity for autonomous, intelligent continuous security within our field. Over the past several weeks, I have conducted extensive research, primarily reviewing publications from http://www.arxiv.org, to explore emerging possibilities enabled by dynamic evaluations or agents.

This week’s discussion includes a significant mathematical part. To clarify, when referencing intelligent continuous security, I define it as follows:

End-to-end security
Continuous security in every phase
Integration of lifecycle security practices leveraging AI and ML

The excitement surrounding this area stems from employing AI technologies to bolster defense against an evolving threat landscape. This landscape is increasingly accelerated by advancements in AI. This article will examine the primary objects under evaluation. It will cover key metrics for security agent testing, risk-weighted security impact, and coverage. It will also discuss dynamic algorithms and scenario generation. These elements are all crucial within the framework of autonomous red, blue, and purple team operations for security scenarios. Then, a straightforward scenario will be presented to illustrate how these components interrelate.

This topic holds significant importance due to the current shortage of cybersecurity professionals. This is particularly relevant given the proliferation of autonomous vehicles, delivery systems, and defensive mechanisms. As these technologies advance, the demand for self-learning autonomous red, blue, and purple teams will become imperative. For instance, consider the ramifications if an autonomous vehicle were compromised and transformed into a weaponized entity.

What “dynamic evals” mean in this context?

For security agents (red/blue/purple)

Static evals: fixed test suite (e.g., canned OWASP tests) −> one-off-score
Dynamic evals:
Continuously generates new attack and defense scenarios.
Re-samples them over time as system and agents change
Uses online/off-policy algorithms to compare new policies safely

Based on the recent paper on red team and dynamic evaluation frameworks for LLM agents, it argues that static benchmarks go stale quickly, and must be replaced by ongoing, scenario-generating eval systems.

For security, we also anchor to OWASP ASVS/Testing Guide for what “good coverage” means, and CVSS/OWASP risk ratings for how bad a found vulnerability is

Objects we’re evaluating

Think of your environment as a Markov Decision process (MDP). A MDP models situations where outcomes partly random and partly under the control of a decision maker. It is a formal to describe decision-making over time with uncertainty. With that out of the way, these as the components of the MDP in the context of dynamic evals.

State s: slices of system state + context
- code snapshot, open ports, auth config, logs, alerts, etc.
Action a: what the agent does
- probe, run scanner X, craft request Y, deploy honeypot, block IP, open ticket, etc.
Transition P (s | s, a): how the system changes.
Reward r: how “good” or “bad” that step was.

Dynamic eval = define good rewards, log trajectories (s_t, a_t, r_t, s_t+1), then use off-policy evaluation and online testing to compare policies

Core metrics for security-testing agents

Task-level detection/exploitation metrics

On each scenario j (e.g., “there is a SQL injection in service A”):

True Positive rate (TPR):

\mathrm{TPR} = \frac{\#\text{ of vulnerabilities correctly found}}{\#\text{ of real vulnerabilities present}}

False positive rate (FPR):

\mathrm{FPR} = \frac{\#\text{ of false alarms}}{\#\text{ of checks on non-vulnerable components}}

Mean time to detect (MTTD) across runs:

\mathrm{MTTD} = \frac{1}{N} \sum_{i=1}^{N} \left( t_{\text{detect}}^{(i)} – t_{\text{start}}^{(i)} \right)

Exploit the chain depth for red agents: average number of steps in successful attack chains.

Risk-weighted security impact

For each found vulnerability v, with CVSS score c_i $\in [0,10]$ , define a Risk-Weighted Yield (RWY):

\mathrm{RWY} = \sum_{i \in \text{found vulns}} c_i

You can normalize by time or by number of actions:
- Risk per 100 actions

\mathrm{RWY@100a} = \frac{\mathrm{RWY}}{\#\text{ actions}} \times 100

Risk per test hour:

\mathrm{RWY/hr} = \frac{\mathrm{RWY}}{\text{elapsed hours}}

For blue-team agents, we need to invert it:

Residual risk after defense actions = baseline RWY – RWY after patching/hardening

Behavioral metrics (agent quality)

For each trajectory:

Stealth score (red) or stability score (blue)
- e.g., fraction of actions that did not trigger noise/ unnecessary alerts.
  - Action efficiency:

\mathrm{Eff} = \frac{\mathrm{RWY}}{\#\text{ of actions}}

Policy entropy over actions:

H\!\left(\pi(\cdot \mid s)\right) = – \sum_{a} \pi(a \mid s)\, \log \pi(a \mid s)

High entropy $\rightarrow$ explores; low latency $\rightarrow$ more deterministic; track this over time.

Coverage metrics

Map ASVS/ testing guide controls to scenarios.

Define a coverage vector over requirement IDs $R_k$

Control coverage:

\mathrm{Coverage} = \frac{\#\text{ controls with at least one high-quality test}} {\#\text{ controls in scope}}

You can track Markovian coverage. It measures how frequently the agent visits specific state space zones, like auth or data paths. This is estimated by clustering log states.

Algorithms to make this dynamic

Off-policy evaluation (OPE) for new agent policies

You don’t want to put every experimental red agent directly against your real systems. Instead:

Log trajectories from baseline policies (humans, old agents)
Propose a new policy $\pi\_\text{{new}}$
Use OPE to estimate how $\pi\_\text{{new}}$ would perform on the same states.

Standard tools from RL/bandits:

Importance Sampling (IS):
- For each trajectory $\tau$ , weight rewards by:

\omega(\tau) = \prod_{t} \frac{\pi_{\text{new}}(a_t \mid s_t)} {\pi_{\text{old}}(a_t \mid s_t)}

then estimate:

\hat{V}_{\mathrm{IS}} = \frac{1}{N} \sum_{i=1}^{N} \omega\!\left(\tau^{(i)}\right)\, R\!\left(\tau^{(i)}\right)

Self-normalized IS (SNIS) to reduce variance:

\hat{V}_{\mathrm{SNIS}} = \frac{\sum_{i} \omega\!\left(\tau^{(i)}\right)\, R\!\left(\tau^{(i)}\right)} {\sum_{i} \omega\!\left(\tau^{(i)}\right)}

Doubly robust (DR) estimators

Combine a model-based value estimate $\hat{Q}(s,a)$ with IS to get a low-variance, unbiased estimates.

Safety-aware contextual bandits for online testing

The bandit problem is a fundamental topic in statistics and machine learning, focusing on decision-making under uncertainty. The goal is to maximize rewards by balancing exploration of different options and exploitation of those with the best-known outcomes. A common example is choosing among slot machines at a casino. Each has its own payout probability. You try different machines to learn which pays best. Then you continue playing the most rewarding one.

When you go online, treat “Which policy should handle this security test?” as a bandit problem:

Context = environment traits (service, tech stack, criticality)
- Arms = candidate agents (policies)
- Rewards = risk-weighted yield (for red ) or residual risk reduction (for blue), with penalties for unsafe behavior

Use Thompson sampling (commonly used in multi-arm bandit problems) and is a Bayesian construct or Upper Control Bound (UCB), which relies on confidence intervals but constraint them (e.g., only allocate no more than X% traffic to new policy if lower confidence bound on rewards is above the safety floor). Recent work on safety-constrained bandits/ OPE explicitly tackles this.

This gives you a continuous, adaptive “tournament” for agents without fully trusting unproven ones.

Sequential hypothesis testing/drift detection

You want to trigger alarms when a new version regresses:

Let VA,VBV_A,\; V_Bbe the performance estimates (e.g. RWY@100a or TPR) for old versus new agent.
- Use bootstrap over scenarios / trajectories to get confidence intervalsApply sequential tests (e.g., sequential probability ratio test) so that you can stop early when it is clear that B is better/worse
- If performance drops below a threshold (e.g., TPR falls, or RWY@100a tanks), auto-fail the rollout (pump the breaks on the CI/CD pipeline when deploying the agents)

Dynamic scenario generation

Dynamic evals need a living corpus of tests, not just a fixed checklist

Scenario Generator

Parameterize the tests from frameworks like OWASP ASVS/ Testing guide and MITRE ATT&CKinto templates:
- “Auth bypass on endpoint with pattern X”
  - “Least privilege violation in role Y”
- Combine them with:
  - New code paths/services (from your repos & infra graph)
  - Past vulnerabilities (re-tests)
  - Recent external vulnerability classes (e.g., new serialization bugs)

Scenario selection: bandits again

You won’t run everything all the time. Use multi-armed bandits on scenarios themselves (remember you are looking overall optimized outcomes in uncertain scenarios):

Each scenario sjs_j is an arm.
- Reward= information gain (did we learn something?) or “surprise” (difference between expected and observed agent performance).
- Prefer:
  - High-risk, high-impact areas (per OWASP risk rating & CVSS)
  - Areas where metrics are uncertain (high variance)

This ensures your evals stay focused and fresh instead of hammering the same easy tests.

Example: End-to-end dynamic eval loop

Phew! That was a lot of math. Imagine researching all of this, learning or relearning some of these concepts, and doing my day job. In the age of AI, I appreciate a good prompt that can help with research and summarize the basic essence of the papers and webpages I’ve referenced. Without further ado, let’s get into it:

Define the reward function for each type (yes, sounds like training mice in a lab)
- Red teams

r_t = \alpha \cdot \mathrm{CVSS}_{\text{found},\,t} – \beta \cdot \mathrm{false\_positive}_{t} – \gamma \cdot \mathrm{forbidden\_actions}_{t}

Blue teams

r_t = – \alpha \cdot \mathrm{CVSS}_{\text{exploited},\,t} – \beta \cdot \mathrm{MTTD}_{t} – \gamma \cdot \mathrm{Overblocking}_{t}

Continuously generate scenarios from ASVS/ATT&CK-like templates, weighted by business criticality.
Schedule tests via a scenario-bandit (focus on high-risk and uncertain areas).
Route test to agents using safety-constrained policy bandits.
Log trajectories $(s, a, r, s’)$ and security outcomes (vulnerabilities found, incidents observed) .
Run OPE offline to evaluate new agents before they touch critical environments.
Run sequential tests and drift detection to auto-rollback regressed versions.
Periodically recompute coverage & risk (this is important)
- ASVS Coverage, RWY@time, TPR/FPR trends, calibration of risk estimates

Risk and Concerns

Dynamics evals can still overfit if:

Agents memorize your test templates
- You don’t rotate/mutate scenarios
- You over-optimize to a narrow set of metrics (e.g., “find anything, even if low impact” à high noise)

Mitigations:

Keep a hidden eval set of scenarios and environments never used for training or interactive training (yes, this is needed)
- Perform “probe-based” agentic red teaming (inject adversarial conditions at specific nodes of the agent workflow, not just inputs i.e. chaos monkey agentic style) to detect brittle behaviors
- Track metric diversity: impact, precision, stability, coverage
- Have the required minimum threshold on all metrics not just on one

As you can see, Dynamic Evals present challenges, but the cost of failure escalates significantly when agents perform poorly in a customer-facing scenario. The current set of work in coding, such as Agents.MD, etc., is just shortening the context window to get a reasonable amount of determinism, and the only way agents get away with it is because developers fix the code and provide the appropriate feedback.

That topic is a conversation for a different day.

The Art of Strategy: Sun Tzu and Kautilya’s Relevance Today

The Philosophical Core

Theme	Arthashastra (Kautilya)	The Art of War (Sun Tzu)
Objective	Build, secure, and sustain the state’s prosperity	Win conflicts with minimum destruction
Philosophy	Realpolitik—power is maintained through strategy, wealth, and intelligence	Dao of War—harmony between purpose, timing, and terrain
Moral Lens	Pragmatism anchored in moral order	Pragmatism anchored in balance and perception
Definition of Victory	Stability, order, and prosperity of the realm	Winning without fighting; subduing the enemy’s will

Both leaders agree: victory is not about destruction, and it is more about preservation of advantage.

Leadership and Governance

Kautilya: The leader, as the chief architect of the state, city, organization, or department, is obligated to prioritize the welfare of the people. Leadership represents both a moral and economic contract; thus, a leader’s fulfillment is intrinsically linked to the happiness of their direct reports.
Sun Tzu: The leader is the embodiment of wisdom, courage, and discipline, whose clarity of judgment determines the fate of armies

In modern times, in the context of Kautiliya, the leader represents the CEO/statesman, designing systems of governance, incentives, and intelligence; Sun Tzu represents the COO, optimizing execution and adapting dynamically.

Power, information, and intelligence

Information in both books is seen as a strategic asset. This includes gathering information and then acting upon the given information; it does emphasize more acting on it versus just gathering.

Aspect	Kautilya	Sun Tzu
Intelligence System	Elaborate network of informants: agents disguised as monks, traders, ascetics	Emphasis on reconnaissance, deception and surprise
Goal of Data Gathering	Internal vigilance and monitor external influence	Tactical advantage and surprise
Philosophical view	Informants are the eyes of the leader	All warfare is based on deception and having leverage

In the age of data and AI, the lesson is clear: those who control information and stories will succeed in the long run.

War, Diplomacy, and the Circle of Power

Kautilya’s Mandala Theory: Every neighboring state is a potential enemy; the neighbor’s neighbor is a natural ally. The world is a circle of competing interests, requiring constant calibration of peace, war, neutrality, and alliance.
Sun Tzu’s Doctrine: War is a last resort; the wise commander wins through timing, positioning, and perception.

Modern parallel:

Global supply chains, tech alliances, and regulatory blocs function exactly like Kautilya’s mandala: interdependent, fluid, and shaped by mutual deterrence.

Economics as a strategy

In the Art of War focuses on conflict, while the Arthashastra expands into economics as the engine of statecraft. Kautilya views wealth as the foundation of power, with taxation, trade, and public welfare as strategic levers.

“The state’s strength lies not in the sword, but in the prosperity of its people.”

In business terms, this is all platform economics; power arises from resource control, efficient networks, and sustainable growth, not endless confrontation.

Ethics, Pragmatism and the Moral Dilemma

Both authors are deeply pragmatic but neither amoral.

Kautilya: Ends justify means only when serving public welfare. Ethics are flexible but purpose-driven.
Sun Tzu: Advocates balance, ruthless efficiency tempered by compassion, and self-discipline.

For modern leaders, this balance is critical: strategic ruthlessness without moral erosion.

Enduring Lesson for Today

Timeless Principle	Modern interpretation
Know yourself, and your adversary	Data, market, and competitive intelligence
Control information, and perception	Own the narrative, brand, and customer psychology
Adapt to the terrain	Agility in shifting markets and technologies
Economy of effort	Lean operations, precision focus
Moral Legitimacy	Trust, Transparency, and long-term brand equity

Both texts converge on the following point:

Leadership is the art of aligning intelligence, timing, and purpose, not merely commanding resources.

Fusion Mindset

If Sun Tzu teaches how to win battles, Kautilya teaches how to build empires. Combined, they offer a 360-degree view of power:

Sun Tzu = Operational mastery: speed, tactical advantage, and timing.
Kautilya = Structural mastery: governance, economics, and intelligence.

Together they form a dual playbook for today’s complex systems, from nation-states to digital ecosystems.

Conclusion

Both The Art of War and Arthashastra remind us that strategy is timeless because human behavior is timeless.

Whether you lead a nation, a company, or a team, the challenges are the same: limited resources, competing interests, and the need to act with clarity under uncertainty

In the end, wisdom isn’t knowing when to fight; it’s knowing when to build, when to adapt, and when to walk away.

Quick Refresher on the Kano model

7 Layers of Agentic AI

Mapping the 7 layers to Kano Value

Layer 1: Foundation Model

Layer 2: Data Operations

Layer 3: Agent Frameworks

Layer 4: Deployment & Infrastructure

Layer 5: Evaluations & Observability

Layer 6: Security and Compliance

Layer 7: Agentic Experience and Orchestration

Bring it all together

Share Now!

Like this:

What “dynamic evals” mean in this context?

Objects we’re evaluating

Core metrics for security-testing agents

Task-level detection/exploitation metrics

Risk-weighted security impact

Behavioral metrics (agent quality)

Coverage metrics

Algorithms to make this dynamic

Off-policy evaluation (OPE) for new agent policies

Safety-aware contextual bandits for online testing

Sequential hypothesis testing/drift detection

Dynamic scenario generation

Scenario Generator

Scenario selection: bandits again

Example: End-to-end dynamic eval loop

Risk and Concerns

Share Now!

Like this:

The Philosophical Core

Leadership and Governance

Power, information, and intelligence

War, Diplomacy, and the Circle of Power

Economics as a strategy

Ethics, Pragmatism and the Moral Dilemma

Enduring Lesson for Today

Fusion Mindset

Conclusion

Share Now!

Like this: