The Problem I Actually Wanted to Solve

I started Fenra because I kept reading about corruption cases in Kenya where the patterns were obvious in hindsight—strange procurement patterns, shell companies, duplicate payments—but nobody caught them in real-time. The data was there, scattered across different systems. The connections were there too, but buried under too much noise for humans to spot quickly.

My first thought: build one smart AI that can read everything and tell you when something looks corrupt.

That didn’t work.

Why Single AI Models Fail at This

I tried the obvious approach first. Feed documents into a large language model, ask “is this corrupt?” The results were either:

• Too vague (“this seems suspicious” — thanks, but why?)
• Too confident (flagging legitimate transactions because of unusual but legal patterns)
• Or missing things entirely (not understanding that two shell companies sharing a director matters)

The problem isn’t that LLMs are dumb. It’s that corruption detection requires multiple types of reasoning at once:

• Pattern matching (unusual transaction amounts, timing)
• Relationship tracing (who knows who, company networks)
• Legal knowledge (what actually violates procurement laws)
• Context awareness (this is normal for this industry, weird for that one)

No single model is good at all of these. And even if one was, I didn’t want a black box making accusations.

The Swarm Idea

I started thinking about how actual investigations work. You don’t have one super-detective who does everything. You have:

• A forensic accountant who traces money
• A network analyst who maps relationships
• A legal researcher who knows the regulations
• A senior investigator who reviews findings before anything goes to court

So I built Fenra as a swarm. Multiple specialized agents, each with a specific job, coordinated by a “Judge” that verifies conclusions before they’re reported.

Why Graph RAG Was the Right Choice

Early on, I tried standard RAG (Retrieval-Augmented Generation) — chunk documents, embed them, retrieve relevant chunks when querying. It worked for simple questions but failed on relationships.

Example: Company A paid Company B. Company B’s director is the cousin of a procurement officer. That’s three hops. Standard vector search doesn’t handle hops well.

Graph RAG stores entities (companies, people, transactions) as nodes and relationships as edges. Now the “network analyst” agent can actually traverse connections—follow the money, find shared directors, spot circular payments.

The graph also gives us explainability. When Fenra flags something, we can show the path:

“Flagged because Company A → paid → Company B → director is → Person C → related to → Procurement Officer D.”

The Architecture That Actually Works

Here’s what I ended up with:

Specialist Agents (The Workers)

• Transaction Analyzer: Looks at financial patterns, outliers, timing anomalies
• Network Mapper: Traverses the knowledge graph to find hidden relationships
• Legal Checker: Knows procurement regulations, flags procedural violations
• Document Reader: Extracts entities and relationships from unstructured text (contracts, emails)

The Judge (The Verifier)

• Takes findings from specialists and verifies them against evidence
• Checks for contradictions between agents
• Assigns confidence scores
• Only escalates high-confidence, well-supported findings

The Graph Store

• Neo4j for relationship data (who knows who, ownership structures)
• Vector store for semantic search (finding similar contract language, for example)
• Both feed into each other — vector search finds relevant documents, graph traversal finds connections within them

Why OCaml and Erlang

I get asked why I didn’t just use Python like everyone else. A few reasons:

OCaml for the core logic: Corruption detection involves a lot of data transformation and rule evaluation. OCaml’s type system catches bugs at compile time that would be runtime errors in Python. When you’re dealing with legal and financial data, “oops, NoneType has no attribute” isn’t acceptable.

Also, hot code reloading means I can update an agent’s logic without stopping the system. Important when you’re iterating on detection rules.

What I Learned the Hard Way

1. Start with synthetic data: I spent weeks trying to get real procurement data. Don’t. Generate fake but realistic corruption patterns first. If your system can’t find fake corruption you planted yourself, it won’t find real corruption either.

2. The graph schema matters more than the model: I wasted time fine-tuning LLMs when the real problem was my graph schema didn’t capture “subsidiary of” relationships properly. Fix your data model first.

3. Explainability is not optional: In a real deployment, every flag Fenra raises will be challenged. “The AI said so” is not a defense. The graph structure gives us audit trails by default.

4. Human-in-the-loop is a feature, not a bug: The Judge agent doesn’t just verify AI outputs—it creates a checkpoint where human investigators can review, correct, and improve the system. The goal isn’t to replace investigators, it’s to make them 10x more effective.

The Problem

Corruption in procurement leaves traces across multiple systems—financial records, company registries, contract documents. The patterns are obvious in hindsight but buried under noise in real-time. Single AI models fail because corruption detection requires simultaneous reasoning about:

• Financial anomalies (pattern matching)
• Relationship networks (graph traversal)
• Legal compliance (rule evaluation)
• Industry context (domain knowledge)

The Swarm Architecture

Specialist Agents (The Workers):

• Transaction Analyzer: Detects outliers in amounts, timing, and frequency
• Network Mapper: Traverses knowledge graphs to find hidden relationships between companies and officials
• Legal Checker: Flags procedural violations against procurement regulations
• Document Reader: Extracts entities and relationships from unstructured text

The Judge (The Verifier):

• Validates findings against evidence
• Checks for contradictions between agents
• Assigns confidence scores
• Only escalates high-confidence, well-supported flags

Graph RAG

Fenra uses Graph RAG instead of standard vector search. Entities (companies, people, transactions) are nodes; relationships are edges. This enables multi-hop reasoning:

“Company A paid Company B → Company B’s director is Person C → Person C is related to Procurement Officer D”

The graph structure also provides explainability—every flag comes with an auditable path.

Tech Stack

• Neo4j for relationship data and graph traversal
• Vector store for semantic search over documents
• OCaml for the core logic—type safety for financial and legal data
• Erlang for agent orchestration—hot code reloading without downtime

What It Does

• Multi-gateway ingestion: Pulls transactions from M-Pesa, bank APIs, Stripe, and other payment providers
• AI-driven reconciliation: Automatically matches payments to invoices, categorizes expenses, and flags anomalies
• Immutable tax rules: Kenyan tax regulations encoded as verifiable logic—no guesswork, no drift
• Direct KRA filing: Files returns directly to the Kenya Revenue Authority via eTIMS/GavaConnect APIs

Why Agentic?

Instead of rigid automation, Kowalski uses specialized agents that handle different aspects of tax compliance:

• Ingestion Agent: Handles API connections, rate limiting, and data normalization
• Reconciliation Agent: Uses ML to match fuzzy transaction descriptions to actual business activities
• Compliance Agent: Applies Kenyan tax rules (VAT, income tax, withholding) to categorized transactions
• Filing Agent: Prepares and submits returns, handling KRA’s specific formatting requirements

Each agent reports to a supervisor that ensures consistency and flags edge cases for human review.

Built With

• OCaml for the tax rule engine—type safety is non-negotiable when dealing with government compliance
• Erlang/OTP for the agent orchestration—fault tolerance and hot code reloading are essential for financial systems
• LLMs for classification and anomaly detection, constrained by structured output schemas

Between one person and another, the difference is not holiness. It is imagination. It is discipline. It is timing.

Some people are not better. They were simply positioned well — the right place, the right moment. Luck and circumstance shape more than we like to admit.

There is no manual for life. Anyone who claims to have one is selling comfort, not truth.

Happiness is temporary. It rises and falls with events. Joy is deeper. Joy is alignment. It is the quiet certainty that you are living in a way that belongs to you. You find it in people, in art, in friendship, and in work that feels honest.

You control your choices. You do not control the outcome. That is enough.

Choose a direction. Choose your values. Choose your effort. Results are not yours to command. Trust the path anyway. Choosing yourself means acting in a way you can stand behind, whatever follows.

Freedom is internal. No one can read your thoughts without your consent. No one can live inside your head. Even in a rigid world, your inner world is yours.

We are conscious animals in a wild universe. If death is certain, creation is defiance.

When you write, build, design, or code, you push back against decay. You make a mark that proves awareness was here. For me, that mark is programming and writing — tiny acts of rebellion against entropy.

Structure is a tool, not a master. Invention rarely comes from chaos alone. It comes from people who know the rules, then bend them. You do not reject structure — you refuse to disappear inside it.

Do not look down on anyone. We all enter the world the same way. We all leave the same way. Status is temporary. Flesh is equal.

Each day fades and will not return. This is not tragedy. It is clarity. Live so you do not betray yourself. Regret weighs more than failure.

Do not chase happiness. Do not chase approval. Create.

Create because it sharpens your mind. Create because it feels true. Create because it is the only clear proof that you were here.

You came with nothing. You will leave with nothing. Between those two points is a brief window. Use it to build something that reflects you.

Be yourself — not loudly, not theatrically — but deliberately. Live aligned. Let your death be not theft, but completion.

Children are interesting creatures. Alive with dreams, energy, a happiness that costs nothing. They inhabit wonder the way fish inhabit water naturally, completely, without knowing they are wet.

Then they are told to “grow up.”

Society arrives with its expectations, its imaginary rulebook for how life must be lived. But here is what the rulebook never admits: it is written specifically to kill the thing that makes you human.

The Disappearance of Wonder happens slowly. It is not one dramatic death. It is a thousand small withdrawals. The tree stops being a castle and becomes lumber. The cloud stops being a dragon and becomes precipitation. The stranger stops being a potential friend and becomes a threat, a competitor, a demographic. You learn to measure everything time, love, success, beauty until nothing remains that cannot be weighed. The energy vanishes not because you aged, but because you stopped allowing yourself to be astonished.

You learn to wear masks. You pretend to be someone “grown up,” which mostly means someone bored, someone tired, someone who already knows how the story ends. Happiness becomes a metric, a checklist of requirements you must meet before you are allowed to feel it. Dreams shrink because someone drew a line between possible and impossible and you believed them. You stopped asking why and started asking how much.

Happy at heart, brain, and soul. If you, like me, have felt this fraud the sense that you are performing a role rather than living a life step back. Question everything you are right now. Ask who wrote the rules you follow. Ask when you last stood still simply because the light was hitting the wall in a way that made your chest ache.

Others will argue that people simply change. That this narrowing is natural, necessary, mature. But I think the child in you does not change. That child remains your light, your compass. The imagination was alive then not because you were naive, but because you were honest. The intentions were pure not because you were ignorant, but because you were true.

We follow our hearts by essence but if the heart is not pure, it misleads, and peace remains impossible.

So become the baby again. Let the wonder return. Look at the world as if you have never seen it, because in truth, you never have you have only been looking at your ideas about it. Only when the wonder returns does true imagination awaken. Only then do you live the life you love.

It is never too late.

As long as your heart beats.

But life is fuzzy, a float precision, Full of race conditions and blurred vision. We debug the world line by line, Hoping the output will be divine.

Is the universe just a recursive call? Or are we trapped in an endless while(true) loop after all?

Features

• Blazing Fast: Startup time < 50ms.
• LSP Support: Native LSP integration for TypeScript, Go, Rust, OCaml, and more.
• Plugin Manager: Uses lazy.nvim for efficient plugin loading.
• Aesthetics: Custom colorscheme integration (Flexoki support included).

Check out the repository for installation instructions.

I’m that programmer who reads programming language theory for fun and genuinely enjoys compiler design. While others debate framework-of-the-week, I’m deep in the ML family, OCaml is my daily driver, and yes, I use the type system to prevent bugs before they happen.

My Toolbox

OCaml — My daily driver. The type system catches bugs before they exist, and hot code reloading means I can iterate without downtime. I use it for anything that needs to stay standing.

TypeScript — When I have to touch the web, I want types. It’s JavaScript that won’t stab you in production at 3am.

Python — Still the best for gluing things together, scripting, and when the AI ecosystem hasn’t caught up to ML family languages yet.

Neovim — My editor of choice. Custom config in Lua, sub-50ms startup, LSP for everything. I don’t fight my tools; they disappear.

Pi Coding Agent — My pair programmer that doesn’t sleep. Good for scaffolding, refactoring, and rubber-ducking at scale.

Philosophy

I admire Mat Armstrong’s approach: solve the actual problem, ignore the hype, write code that makes sense six months later. Complexity is a bug, not a feature. If you need a diagram to explain your architecture, your architecture is wrong.

Currently Building

• Kowalski — A set-and-forget tax agentic platform for Kenyan SMEs. OCaml for the rules engine, Erlang for agent orchestration, direct KRA filing via eTIMS.
• Fenra — A swarm intelligence system for detecting corruption in public procurement. Multi-agent architecture with Graph RAG for relationship tracing.

The Goal

Uncomplicate things. Make programming accessible. Prove that elegant solutions exist—you just have to stop accepting messy ones.

“The best code is the code you don’t have to write. The second best is the code you write once and never touch again.”

Programming is not glamorous. It is not about showing off frameworks or boasting about your GitHub streak. It is about sitting there, staring at a problem, feeling your brain ache a little, and then — suddenly — a door opens, a tiny mechanism clicks, and the machine obeys. That moment is bliss, more than any job title or paycheck.

Charles Bukowski said writing is a gut feeling, a way to bleed yourself onto the page. Programming is the same, only your bleeding is logic, your words are functions, your paragraphs are data structures. Sussman would tell you it is about understanding the system, the abstraction, not just hacking on the surface. Paul Graham would tell you to build something people want, to start with what fascinates you, and then sweat the details until your code becomes invisible, elegant, and powerful.

If you want to be a programmer, be prepared to fail. Be prepared to love the failures, because every bug is a teacher, every crash is a conversation. Be authentic. Write code like you breathe — messy, desperate, alive.

Programming is not a career. It is a calling. And if you want it, you will not be stopped by languages, frameworks, or abstractions. You will be stopped only by yourself.

Last updated: January 2026

Building

Flowy — A Telegram mini app for money and commerce. Making payments simple inside the app you already use.

Lisp Interpreter — In OCaml, because every programmer needs to write a Lisp at least once.

Learning

• Reading through The Art of Computer Programming (Knuth) — Volume 4B at the moment
• Diving deeper into distributed systems and consensus algorithms
• Trying to finally understand monads in Haskell (still pretending)

Using

• Editor: Neovim with my own config
• Language: OCaml for serious work, Python for quick scripts
• OS: macOS with a heavily customized terminal setup

Reading

• Structure and Interpretation of Computer Programs (SICP) — re-reading, still learning new things
• Various papers on type theory and compiler design