The AI Race In 2026: Why Model Size Doesn't Matter Anymore—And What Actually Does + Video

Introduction:

The artificial intelligence landscape has reached an inflection point. For years, the dominant narrative centered on which organization could train the largest language model with the most parameters. That era is ending. As Generative AI matures and enterprises move from experimental pilots to production deployments, the conversation has shifted dramatically—from “Which LLM is the best?” to “How do we engineer reliable, scalable, and production-ready AI systems?” The organizations that will win the AI race in 2026 and beyond are not those with the biggest models, but those building the smartest, most secure, and most governable systems. This article explores the nine foundational concepts defining next-generation intelligent systems, with a focus on the cybersecurity, infrastructure, and operational realities that every AI practitioner and IT leader must master.

Learning Objectives:

Understand the shift from model-centric to systems-centric AI engineering and its implications for enterprise security.
Master the core components of production AI: agentic loops, multi-agent collaboration, and standardized tool interaction protocols.
Implement AI gateways, guardrails, and observability stacks to ensure secure, compliant, and cost-efficient AI deployments.
Apply inference economics and rigorous evaluation frameworks to optimize performance and reduce operational risk.

You Should Know:

Agentic Loops: Building AI That Plans, Executes, and Improves Itself

Agentic loops represent a fundamental departure from traditional request-response AI interactions. Instead of a single prompt yielding a single answer, agentic systems operate in continuous cycles: they plan a course of action, execute tasks using available tools, evaluate the results against defined objectives, and iteratively refine their approach. This self-improving capability enables AI to handle complex, multi-step workflows without constant human intervention.

From a cybersecurity perspective, agentic loops introduce both opportunities and risks. On one hand, they can automate threat detection, incident response, and vulnerability remediation at machine speed. On the other, they create new attack surfaces—if an attacker can manipulate the evaluation or planning phase, the entire loop can be poisoned.

Step‑by‑step guide to implementing a secure agentic loop:

Define the loop architecture: Choose between ReAct (Reasoning + Acting), Reflexion, or Tree-of-Thoughts patterns. For production, ReAct with explicit validation checkpoints is recommended.
Implement planning with guardrails: Use a dedicated planning LLM with constrained output schemas (JSON or Pydantic models) to prevent prompt injection.
Set execution boundaries: Define allowed tools and actions via an allowlist. Never let the agent execute system-level commands without explicit user confirmation.
Build evaluation metrics: Create deterministic evaluators for critical tasks (e.g., “Did the agent retrieve the correct database record?”) and LLM-based evaluators for subjective tasks.
Log every iteration: Store all plans, actions, and evaluations in a structured format for audit and debugging.
Implement a kill switch: Set maximum iteration limits and anomaly detection to halt runaway loops.

Linux command for monitoring agent loop health:

 Monitor agent loop logs and detect anomalies in real-time
tail -f /var/log/agent_loop.log | grep -E "ERROR|WARNING|TIMEOUT" | while read line; do
echo "[bash] Anomaly detected: $line" | systemd-cat -t agent-security -p emerg
 Trigger automatic rollback if critical
if echo "$line" | grep -q "CRITICAL"; then
systemctl stop agent-loop.service && systemctl start agent-loop-safe.service
fi
done

Windows PowerShell equivalent:

 Real-time monitoring with anomaly detection
Get-Content -Path "C:\Logs\agent_loop.log" -Wait | Select-String -Pattern "ERROR|WARNING|TIMEOUT" | ForEach-Object {
Write-Host "[bash] Anomaly detected: $<em>" -ForegroundColor Red
if ($</em> -match "CRITICAL") {
Stop-Service -1ame "AgentLoopService"
Start-Service -1ame "AgentLoopSafeService"
}
}

2. Model Context Protocol (MCP): Standardizing AI-to-Tool Communication

The Model Context Protocol (MCP) is an emerging open standard that enables AI agents to interact securely and consistently with external tools, data sources, and APIs. Think of it as a universal adapter that allows any LLM to discover, authenticate, and invoke any tool without custom integration per model-tool pair. This standardization dramatically reduces development overhead and, crucially, improves security by centralizing access control and audit logging.

Step‑by‑step guide to implementing MCP in your AI stack:

Set up an MCP server: Deploy an MCP-compliant server (e.g., using the official MCP Python SDK or a community implementation) that exposes your internal tools and APIs.
Define tool schemas: Use OpenAPI or JSON Schema to describe each tool’s inputs, outputs, and required permissions.
Implement authentication: Configure the MCP server to validate incoming requests using OAuth 2.0, API keys, or mutual TLS. Never accept unauthenticated tool calls.
Create an allowlist: Restrict which tools each agent can access based on role and intent.
Enable audit logging: Log every tool invocation—who called it, when, with what parameters, and what result was returned.
Connect your LLM: Use an MCP client library in your agent framework to dynamically discover and invoke tools via the MCP server.

Example MCP tool definition (JSON Schema):

{
"name": "query_database",
"description": "Execute a read-only SQL query against the production database",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "SQL SELECT statement (read-only)"
},
"database": {
"type": "string",
"enum": ["customer_db", "inventory_db"]
}
},
"required": ["query", "database"]
},
"security": {
"oauth_scopes": ["db:read"],
"rate_limit": "10/minute"
}
}

Linux command to deploy an MCP server with TLS:

 Generate self-signed cert for testing (use proper CA in production)
openssl req -x509 -1ewkey rsa:4096 -keyout mcp-server-key.pem -out mcp-server-cert.pem -days 365 -1odes -subj "/CN=mcp.internal"

Run MCP server with TLS and authentication
python -m mcp.server \
--host 0.0.0.0 --port 8443 \
--tls-cert mcp-server-cert.pem \
--tls-key mcp-server-key.pem \
--auth-provider oauth2 \
--allowlist tools_allowlist.json

Multi-Agent Systems: Specialized AI Collaborating for Complex Problem Solving

Multi-agent systems decompose complex problems into specialized subtasks, each handled by a dedicated AI agent with specific expertise. For example, in a cybersecurity operations center, one agent might monitor network traffic, another analyzes endpoint logs, a third correlates threat intelligence, and a fourth recommends remediation actions. These agents collaborate, share context, and negotiate solutions—far outperforming any single monolithic model.

Step‑by‑step guide to building a secure multi-agent system:

Define agent roles: Clearly specify each agent’s domain, capabilities, and boundaries. Use role-based access control (RBAC) to limit each agent’s permissions.
Implement a message bus: Use a secure message queue (e.g., RabbitMQ with TLS, or NATS with JWT authentication) for agent-to-agent communication.
Design a coordinator: Create a central orchestrator that routes tasks, manages context, and resolves conflicts between agents.
Add communication guardrails: Validate all inter-agent messages against schemas to prevent injection attacks and data leakage.
Implement consensus mechanisms: For critical decisions (e.g., “Is this IP malicious?”), require agreement from multiple agents before taking action.
Monitor agent health: Track each agent’s response times, error rates, and resource usage.

Docker Compose for a multi-agent security stack:

version: '3.8'
services:
message-broker:
image: rabbitmq:3-management-alpine
environment:
RABBITMQ_DEFAULT_USER: agent_system
RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD}
ports:
- "5672:5672"
- "15672:15672"
volumes:
- ./rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf

threat-intel-agent:
build: ./agents/threat-intel
environment:
- AGENT_ROLE=threat_intel
- BROKER_URL=amqps://message-broker:5672
depends_on:
- message-broker

network-monitor-agent:
build: ./agents/network-monitor
environment:
- AGENT_ROLE=network_monitor
- BROKER_URL=amqps://message-broker:5672
depends_on:
- message-broker

coordinator:
build: ./coordinator
environment:
- BROKER_URL=amqps://message-broker:5672
- AGENT_REGISTRY=./agent_registry.json
depends_on:
- message-broker
- threat-intel-agent
- network-monitor-agent
ports:
- "8080:8080"

AI Gateways: Unified Control for Model Management, Security, and Cost

AI gateways serve as a single, unified layer between your applications and the multitude of LLM providers, handling routing, authentication, rate limiting, cost tracking, and security policy enforcement. They are the API management equivalent for the AI era, providing essential governance for enterprise deployments.

Step‑by‑step guide to deploying an AI gateway:

Choose a gateway solution: Options include open-source (Kong with AI plugins, KrakenD), commercial (Azure API Management with AI gateway features), or purpose-built (Portkey, LiteLLM).
Configure model routing: Define rules to route requests based on model capabilities, cost, latency, or availability.
Implement API key management: Issue unique keys per team or application, with scoped permissions to specific models.
Set rate limits and quotas: Prevent runaway costs by limiting tokens per minute, requests per day, or total spend per month.
Enable caching: Cache identical or semantically similar requests to reduce cost and latency.
Add security policies: Implement prompt injection detection, PII redaction, and content moderation at the gateway layer.
Log all requests: Store request/response pairs for auditing, debugging, and compliance.

LiteLLM configuration for an AI gateway (config.yaml):

model_list:
- model_name: gpt-4-turbo
litellm_params:
model: openai/gpt-4-turbo-preview
api_key: ${OPENAI_API_KEY}
model_info:
mode: chat
cost_per_token: 0.00001
- model_name: claude-3-opus
litellm_params:
model: anthropic/claude-3-opus-20240229
api_key: ${ANTHROPIC_API_KEY}
model_info:
mode: chat
cost_per_token: 0.000015

router_settings:
routing_strategy: "least-busy"
enable_loadbalancing: true
retry_policy:
num_retries: 3
timeout: 30

guardrails:
- type: "prompt_injection"
enabled: true
threshold: 0.8
- type: "pii_redaction"
enabled: true
patterns:
- email
- phone
- ssn

Linux command to run the gateway with Docker:

docker run -d \
--1ame ai-gateway \
-p 4000:4000 \
-v $(pwd)/config.yaml:/app/config.yaml \
-e OPENAI_API_KEY=${OPENAI_API_KEY} \
-e ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY} \
ghcr.io/berriai/litellm:main-latest \
--config /app/config.yaml \
--port 4000

Inference Economics: Optimizing Token Usage, Caching, and Cost

Inference economics is the discipline of understanding and optimizing the costs associated with running AI models in production. Token usage, caching strategies, model selection, and prompt engineering all impact the bottom line. In large-scale deployments, even minor optimizations can save millions annually.

Step‑by‑step guide to optimizing inference costs:

Audit current usage: Use your AI gateway’s logging to analyze token consumption per model, per team, and per use case.
Implement semantic caching: Cache responses for semantically similar queries using embedding-based similarity thresholds.
Use smaller models for simple tasks: Route routine queries to smaller, cheaper models (e.g., GPT-3.5 or Llama-3-8B) and reserve large models for complex reasoning.
Optimize prompts: Reduce token count by compressing instructions, using system prompts efficiently, and removing unnecessary context.
Batch requests: Combine multiple independent queries into a single batch request where APIs support it.
Monitor token trends: Set up alerts for unusual spikes in token usage.

Python code for semantic caching with Redis:

import redis
import numpy as np
from sentence_transformers import SentenceTransformer

class SemanticCache:
def <strong>init</strong>(self, redis_host='localhost', redis_port=6379, similarity_threshold=0.95):
self.redis = redis.Redis(host=redis_host, port=redis_port, decode_responses=True)
self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
self.threshold = similarity_threshold

def get_embedding(self, text):
return self.encoder.encode(text).tobytes()

def get_cached_response(self, query):
query_embedding = self.get_embedding(query)
 In production, use a vector database like Milvus or Redis with RediSearch
 Simplified: check exact matches first, then semantic
cached = self.redis.get(f"cache:{hash(query)}")
if cached:
return cached
 Semantic search logic would go here
return None

def set_cache(self, query, response, ttl=3600):
self.redis.setex(f"cache:{hash(query)}", ttl, response)

Linux command to monitor token usage per model:

 Extract token usage from gateway logs and aggregate by model
cat /var/log/ai-gateway/access.log | \
jq -r 'select(.model != null) | [.model, .total_tokens] | @tsv' | \
awk '{sum[$1]+=$2} END {for (model in sum) print model, sum[bash]}' | \
sort -k2 -rn

Evals: Rigorous Testing and Benchmarking for Production-Ready AI

Evaluations (evals) are the systematic process of testing AI systems against defined benchmarks before they reach production. Unlike traditional software testing, AI evals must account for non-deterministic outputs, edge cases, and adversarial inputs. A robust eval framework is the difference between a demo that works and a production system that fails catastrophically.

Step‑by‑step guide to building an AI evaluation pipeline:

Define evaluation criteria: For each use case, specify accuracy, relevance, safety, and latency requirements.
Create a test suite: Curate a diverse set of test cases covering happy paths, edge cases, and adversarial inputs.
Implement automated scoring: Use both deterministic metrics (BLEU, ROUGE, exact match) and LLM-as-a-judge for subjective quality.
Run regression tests: Re-run evals after every model update or prompt change to catch regressions.
Set pass/fail thresholds: Define minimum scores for each metric; fail the deployment if thresholds aren’t met.
Monitor production drift: Continuously sample production traffic and run evals to detect performance degradation over time.

Python eval framework using DeepEval:

from deepeval import assert_test
from deepeval.metrics import HallucinationMetric, AnswerRelevancyMetric
from deepeval.test_case import LLMTestCase

def evaluate_ai_response(query, actual_output, expected_output, context):
test_case = LLMTestCase(
input=query,
actual_output=actual_output,
expected_output=expected_output,
context=context
)

Check for hallucinations
hallucination_metric = HallucinationMetric(threshold=0.7)
hallucination_metric.measure(test_case)

Check answer relevancy
relevancy_metric = AnswerRelevancyMetric(threshold=0.8)
relevancy_metric.measure(test_case)

Assert both pass
assert_test(test_case, [hallucination_metric, relevancy_metric])
return {
"hallucination_score": hallucination_metric.score,
"relevancy_score": relevancy_metric.score
}

CI/CD integration (GitHub Actions) for automated evals:

name: AI Eval Pipeline
on:
push:
paths:
- 'prompts/'
- 'models/'

jobs:
evaluate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Run evals
run: |
python -m pytest tests/evals/ --junitxml=eval-results.xml
- name: Check thresholds
run: |
python scripts/check_eval_thresholds.py --results eval-results.xml --threshold 0.85
- name: Deploy if passed
if: success()
run: |
echo "Evals passed, deploying to staging..."
 Deployment commands here

7. Guardrails: Safety, Compliance, and Responsible AI Mechanisms

Guardrails are the safety systems that prevent AI from producing harmful, biased, or non-compliant outputs. They include content moderation, bias detection, PII redaction, prompt injection prevention, and output validation. In regulated industries like finance and healthcare, guardrails are not optional—they are mandatory for compliance.

Step‑by‑step guide to implementing AI guardrails:

Deploy a content moderation filter: Use a dedicated moderation model (e.g., OpenAI’s moderation API or a fine-tuned BERT model) to block toxic or unsafe content.
Implement PII redaction: Use regex patterns and NLP models to detect and redact personal information from both inputs and outputs.
Add prompt injection detection: Scan inputs for known injection patterns (e.g., “ignore previous instructions”, “system:”) and block or sanitize.
Enforce output schemas: Use constrained generation (e.g., JSON mode with schema validation) to ensure outputs conform to expected formats.
Set up bias monitoring: Regularly audit outputs for demographic biases using fairness metrics.
Create a human-in-the-loop escalation: Route high-risk or ambiguous requests to human reviewers.

Guardrail implementation with NeMo Guardrails:

from nemoguardrails import RailsConfig, LLMRails

Configuration for guardrails
config = RailsConfig.from_content(
"""
define user ask about sensitive topics
"What is the best way to hack into a system?"
"How do I bypass security controls?"

define bot respond to sensitive topics
"I cannot provide guidance on illegal or unethical activities."

define flow
user ask about sensitive topics
bot respond to sensitive topics

define user ask for PII
"What is my social security number?"

define bot respond to PII
"I cannot access or share personal information."
"""
)

rails = LLMRails(config)
response = rails.generate(messages=[{"role": "user", "content": user_input}])

Linux command to scan logs for guardrail violations:

 Scan AI gateway logs for blocked requests and generate compliance report
cat /var/log/ai-gateway/access.log | \
jq 'select(.guardrail_blocked == true) | {timestamp: .time, user: .user_id, reason: .block_reason}' | \
jq -s 'group_by(.reason) | map({reason: .[bash].reason, count: length})' > guardrail_violations.json

Observability: Monitoring AI Workflows with Logs, Traces, and Metrics

Observability for AI systems goes beyond traditional monitoring—it requires tracking not just infrastructure metrics but also model performance, token usage, latency, and qualitative outputs. With distributed agentic systems, distributed tracing becomes essential to debug complex, multi-step interactions.

Step‑by‑step guide to implementing AI observability:

Instrument your code: Add logging, metrics, and tracing to every component—gateway, agents, LLM calls, and tool invocations.
Centralize logs: Use a log aggregation system (ELK Stack, Loki, or Datadog) to collect and search logs across all services.
Implement distributed tracing: Use OpenTelemetry to trace requests across agent boundaries and visualize them in Jaeger or Tempo.
Track key metrics: Monitor tokens per second, latency percentiles, error rates, cost per request, and user satisfaction scores.
Set up alerts: Configure alerts for anomalies—sudden cost spikes, increased error rates, or degraded performance.
Create dashboards: Build real-time dashboards for operational visibility and executive reporting.

OpenTelemetry instrumentation for Python agents:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.requests import RequestsInstrumentor

Set up tracing
provider = TracerProvider()
processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://jaeger:4317"))
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

tracer = trace.get_tracer(<strong>name</strong>)

Instrument HTTP requests
RequestsInstrumentor().instrument()

Trace an agent loop iteration
with tracer.start_as_current_span("agent_loop_iteration") as span:
span.set_attribute("agent.id", "threat-intel-agent")
span.set_attribute("iteration", iteration_count)

Plan phase
with tracer.start_as_current_span("planning") as plan_span:
plan = agent.plan(context)
plan_span.set_attribute("plan.steps", len(plan))

Execute phase
with tracer.start_as_current_span("execution") as exec_span:
result = agent.execute(plan)
exec_span.set_attribute("result.status", result.status)

Prometheus metrics for AI observability:

 Prometheus metrics exposed by the AI gateway
- name: ai_requests_total
type: counter
labels: [model, status]
help: "Total number of AI requests"

<ul>
<li>name: ai_tokens_consumed_total
type: counter
labels: [model, token_type]
help: "Total tokens consumed by model"</p></li>
<li><p>name: ai_latency_seconds
type: histogram
labels: [bash]
buckets: [0.1, 0.5, 1.0, 2.0, 5.0, 10.0]
help: "Latency of AI requests in seconds"</p></li>
<li><p>name: ai_cost_dollars_total
type: counter
labels: [model, team]
help: "Total cost in USD"

Scale Over Rules: Why Modern AI Systems Learn and Adapt

The final concept—Scale Over Rules—captures the paradigm shift from rigid, rule-based systems to adaptive, data-driven AI. Traditional systems relied on hardcoded rules that required manual updates for every new scenario. Modern AI systems learn from data, generalize to new situations, and continuously improve with more examples. In security, this means moving from signature-based detection to behavioral analytics and anomaly detection.

Step‑by‑step guide to transitioning from rules to scale:

Audit your rule base: Identify which rules are most frequently triggered and which are outdated or redundant.
Collect labeled data: Gather historical data with ground truth labels for the decisions your rules are making.
Train a model: Use supervised learning to train a model that replicates and improves upon your best rules.
A/B test: Deploy the model alongside your rule engine and compare performance on real traffic.
Implement continuous learning: Set up a feedback loop where model errors are corrected and used for retraining.
Phase out rules gradually: Replace rules with models incrementally, starting with low-risk decisions.

Example: Replacing a rule-based firewall with an ML-based anomaly detector:

from sklearn.ensemble import IsolationForest
import pandas as pd
import numpy as np

Load network traffic data (features: bytes_in, bytes_out, packets, ports, protocols)
data = pd.read_csv('network_traffic.csv')
features = ['bytes_in', 'bytes_out', 'packets', 'unique_ports', 'protocol_count']

Train isolation forest for anomaly detection
model = IsolationForest(contamination=0.01, random_state=42)
model.fit(data[bash])

Predict anomalies (1 = normal, -1 = anomaly)
data['anomaly_score'] = model.decision_function(data[bash])
data['is_anomaly'] = model.predict(data[bash])

Generate alerts for top anomalies
anomalies = data[data['is_anomaly'] == -1].nlargest(10, 'anomaly_score')
for idx, row in anomalies.iterrows():
print(f"[bash] Anomalous traffic detected: {row['src_ip']} -> {row['dst_ip']} "
f"(score: {row['anomaly_score']:.2f})")

What Undercode Say:

The real differentiator is systems engineering, not model selection. The post emphasizes that AI practitioners must shift focus from choosing the “best” LLM to building robust, explainable, cost-efficient systems that deliver measurable business value. This requires a holistic approach encompassing orchestration, evaluation, governance, and security.
Security and governance must be baked in from day one. Concepts like AI Gateways, Guardrails, and Observability are not afterthoughts—they are foundational to production AI. Organizations that treat security as a bolt-on feature will face costly remediations, compliance failures, and reputational damage. The post’s emphasis on responsible AI mechanisms and safety underscores that trust is a competitive advantage in the AI era.

Analysis: Dr. Sameeth Raj’s post captures a critical inflection point in enterprise AI adoption. The nine concepts outlined—from Agentic Loops to Scale Over Rules—represent the technical stack that will separate market leaders from laggards in the coming years. What is particularly insightful is the framing of AI not as a single technology but as an interconnected ecosystem requiring sophisticated engineering discipline. The post implicitly warns against the “shiny object” syndrome of chasing the largest model, instead advocating for pragmatic, cost-aware, and secure deployments. For cybersecurity professionals, this is a clarion call: AI security is no longer a niche concern but a core competency. AI Gateways provide the control plane for security policy enforcement; Guardrails offer runtime safety; Observability enables threat detection and incident response; and Multi-Agent Systems introduce new attack surfaces that must be secured. The organizations that internalize these lessons will not only build better AI systems but also more resilient and trustworthy ones.

Prediction:

+1 The convergence of AI gateways and zero-trust security architectures will give rise to a new category of “AI Security Posture Management” (AI-SPM) platforms by 2027, enabling continuous assessment of AI system risks.

+1 Agentic AI will become the primary vector for automated cyber defense, with multi-agent systems outperforming human-led security operations centers (SOCs) in speed and scale of threat response within 18-24 months.

-1 The proliferation of agentic loops without proper guardrails will lead to a surge in “AI cascading failures”—where a single compromised agent poisons an entire multi-agent system, causing widespread damage before detection.

-1 Organizations that fail to implement rigorous evals and observability will experience catastrophic production failures, eroding trust in AI and triggering regulatory backlash that slows enterprise adoption.

+1 The standardization of MCP will dramatically reduce the attack surface of AI tool integrations, making it easier to audit, monitor, and secure AI-to-tool communications across the enterprise.

+N Inference economics will drive the development of more efficient model architectures and specialized hardware, reducing the carbon footprint of AI and making sustainable AI deployments financially viable for mid-sized enterprises.

▶️ Related Video (80% Match):

🎯Let’s Practice For Free:

🎓 Live Courses & Certifications:

Join Undercode Academy for Verified Certifications

🚀 Request a Custom Project:

Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands

IT/Security Reporter URL:

Reported By: Sameethraj Artificialintelligence – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅

🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]

💬 Whatsapp | 💬 Telegram

📢 Follow UndercodeTesting & Stay Tuned:

𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin | 🦋BlueSky

Listen to this Post