Ama Senevirathne

Sr Full-Stack & AI Systems Engineer · .NET/C# · Python · Angular · Distributed Systems · Agent Architectures · 🟢 Open for Senior / Staff Roles (Remote) · DMs O

[Ama Senevirathne @amasen02]

Loop Engineering: Building Self-Correcting AI Agents Without Token Bloat

Most agent frameworks make a fundamental architectural mistake: they loop the LLM directly on its own conversational history.

By turn 30, the model is re-reading 100,000+ tokens of stale compiler errors and superseded reasoning just to fix a single typo. Beyond the API bill, attention dilution kicks in: the model starts hallucinatory reasoning loops because it begins trusting its own past buggy code.

Here is how to design self-healing agent loops that cut context overhead by 90% while improving pass rates.

---

1: Treat the Model as a Stateless CPU, Not a Database

In traditional systems architecture, a CPU never preserves process state inside its registers across iterations. It reads memory, computes, and writes state back to storage.

Apply that same mental model to LLM workflows:
- Context window is wiped clean to zero on every iteration.
- Persistent state lives on disk in a structured ledger (.agent/cortex.json or SQLite).
- On each step, hydrate only the surgical slice of context needed (typically under 2,000 tokens).

Because the agent never re-reads its full conversation log, token consumption stays flat from step 1 to step 50.

---

2: Filter Tool Logs at the Unix Pipe Level

Never dump raw test outputs or git diffs directly into prompt context. Verbose test runners emit hundreds of lines of irrelevant framework traces and blank lines.

Pipe outputs through CLI filters before prompt injection:

```bash
$ rtk run pytest -v --tb=short | agent-cli --token-cap=2000
```

Stripping redundant stack frames at the OS pipe level routinely eliminates 80% of raw log volume before tokens hit the tokenizer.

---

3: Gating with Subprocess Exit Codes (Never Prompt-Based Self-Evaluation)

Prompting an LLM to evaluate its own code is an anti-pattern. Models suffer from confirmation bias: if a model produced invalid syntax, asking it "does this code look correct?" almost always returns an affirmative hallucination.

Instead, enforce verification through deterministic subprocess return codes:

```python
import subprocess

def test_gate(cmd: list[str]) -> tuple[bool, str]:
proc = https://t.co/qrPpZwKPat(cmd, capture_output=True, text=True)
if proc.returncode != 0:
# Pass only the isolated compiler error diff to the next retry
return False, proc.stderr[-1000:]
return True, ""
```

If the return code is non-zero, feed only the isolated error diff into a fresh, zero-history ephemeral agent instance.

---

4: Atomic Commits to an External Ledger

When local verification passes, commit the verified diff to the disk ledger and immediately terminate the worker:

```python
import json
import time
from pathlib import Path

def commit_step(task_id: str, patch_diff: str):
ledger_file = Path(".agent/cortex.json")
state = json.loads(ledger_file.read_text()) if ledger_file.exists() else {"commits": []}
state["commits"].append({
"task_id": task_id,
"patch": patch_diff,
"timestamp": time.time()
})
ledger_file.write_text(json.dumps(state, indent=2))
```

If a task fails three consecutive gate checks, perform an atomic rollback (git checkout) rather than attempting to patch a contaminated workspace.

---

5: The Ephemeral Fleet Pattern

Instead of one monolithic prompt trying to plan, write, test, and critique simultaneously, split the workflow into short-lived single-responsibility roles:
- Architect: Decomposes requirements into an execution DAG.
- Builders: Ephemeral workers implementing 1 file per branch in isolated git worktrees.
- Tester: Subprocess runner verifying unit test exit codes.
- Critic: Evaluates git diffs and AST complexity with zero author bias.

Key Architectural Rules:
1) LLM = Stateless CPU, Memory = External Disk Ledger.
2) Deterministic compiler exit codes over prompt self-reflection.
3) CLI proxies filter tool logs prior to tokenization.
4) Ephemeral workers: terminate context after each verified commit.
5) Decouple compute from providers: freely route across Claude, GPT-4o, and local models.

[Ama Senevirathne @amasen02]

High-Throughput Zero-Allocation Pipelines in .NET 9:

- Slicing ReadOnlySpan<byte> off sockets
- Bounded Channels for backpressure
- Zero Gen0 GC pauses at 850k req/s

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/csirdxRyoL

[Ama Senevirathne @amasen02]

Bypassing iptables with Cilium eBPF socket filters cuts inter-service microservice latency by 35%.

Zero-copy packet routing directly in the Linux kernel beats user-space sidecar proxies every day of the week.

Modern infrastructure runs inside the kernel.

[Ama Senevirathne @amasen02]

Deep Dive: I Built a Free, Self-Hosted WCAG 2.2 Accessibility Monitor Because $400/Month Is Not an Option for Most of the Web

- Production architecture blueprint
- Working code & benchmarks

Full masterclass & open-source implementation on https://t.co/197f4E7hIt:
https://t.co/40XHL0yd1v

[Ama Senevirathne @amasen02]

Model Context Protocol (MCP) replaced fragmented custom agent plugins overnight.

Standardized JSON-RPC contracts for tools, resources, and live prompts mean one harness connects to every model provider seamlessly.

Tool discovery is now a solved architecture.

[Ama Senevirathne @amasen02]

Running distilled DeepSeek R1 locally for AST linting and test triage cuts cloud API calls by 80%.

Reserve frontier models strictly for architectural plan synthesis.

Tiered multi-model routing is how teams ship without burning $100k in compute.

[Ama Senevirathne @amasen02]

How to build zero-hallucination AI agents in production:

- Negative constraint assertions
- Sub-10ms AST compiler gates
- Ephemeral git worktree rollbacks

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/aan0E1oES5

[Ama Senevirathne @amasen02]

Deep Dive: Agentic AI Orchestration: The Architecture Patterns That Actually Work at Scale

- Production architecture blueprint
- Working code & benchmarks

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/IRaCsIHvCB

[Ama Senevirathne @amasen02]

Flat vector similarity on code embeddings is dead for agents.

Multi-hop AST call graphs resolve imports, interfaces, and symbol dependencies with zero context bloat.

Real software systems are directed graphs, not bag-of-words chunks.

[Ama Senevirathne @amasen02]

The dirty secret in autonomous coding agents: conversational history degrades past turn 30.

Stateless compute + persistent disk ledgers + deterministic compiler exit codes beats chat memory every single time.

Stop prompting your agents to self-reflect.

[Ama Senevirathne @amasen02]

OpenAI o3 solved complex distributed race conditions, but Claude 3.7 wrote the cleaner diff with 40% fewer tokens.

Raw benchmark scores mean nothing if the agent exhausts context after 3 turns.

AST-aware token compaction is the real prod moat.

[Ama Senevirathne @amasen02]

In .NET 9 with Tiered PGO and zero-allocation Channels, C# is clocking 820k req/sec on TechEmpower benchmarks.

That officially edges out Go and matches Rust under real multi-threaded workloads with zero Gen0 GC pauses.

The 2015 'C# is slow' myth is completely dead.

[Ama Senevirathne @amasen02]

Deep Dive: I Built a Free, Self-Hosted WCAG 2.2 Accessibility Monitor Because $400/Month Is Not an Option for Most of the Web

- Production architecture blueprint
- Working code & benchmarks

Full masterclass & open-source implementation on https://t.co/197f4E7hIt:
https://t.co/40XHL0yd1v

[Ama Senevirathne @amasen02]

OpenAI just added real-time Voice Mode directly into Codex.

You talk through architecture edge cases out loud while the agent refactors AST diffs live in your IDE.

10x velocity for senior architects, absolute extinction event for syntax-only coders.

[Ama Senevirathne @amasen02]

Deep Dive: Building a Duplicate-File Scanner in .NET 10: Cheap Checks First, Expensive Ones Last

- Production architecture blueprint
- Working code & benchmarks

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/ya9Rr9Lruj

[Ama Senevirathne @amasen02]

High-Throughput Zero-Allocation Pipelines in .NET 9:

- Slicing ReadOnlySpan<byte> off sockets
- Bounded Channels for backpressure
- Zero Gen0 GC pauses at 850k req/s

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/csirdxRyoL

[Ama Senevirathne @amasen02]

Deep Dive: OWASP LLM Top 10: What Every Engineer Building with AI Needs to Know in 2025

- Production architecture blueprint
- Working code & benchmarks

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/ActOAlR0n1

[Ama Senevirathne @amasen02]

Colossus is training Grok 3 with zero network throttle across 100,000 liquid-cooled GPUs.

Pre-training compute is hitting diminishing returns, shifting the real battle to test-time compute & reasoning RL.

Compute is not the moat. Execution harnesses are.

[Ama Senevirathne @amasen02]

Why Graph Engineering beats flat vector RAG for agents:

- Multi-hop AST relationship tracking
- Zero context window blowouts
- Directed graph memory models

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/qmtO0l5tUt

[Ama Senevirathne @amasen02]

Why Graph Engineering beats flat vector RAG for agents:

- Multi-hop AST relationship tracking
- Zero context window blowouts
- Directed graph memory models

Full masterclass & open-source implementation on https://t.co/2vE6K06ZK8:
https://t.co/Gi4fHXz7wk

[Ama Senevirathne @amasen02]

The real bottleneck in autonomous software agents isn't model intelligence—it's execution harnesses.

Stateless compute + deterministic AST compiler gates + persistent disk memory is the modern engineering stack.