argakiig/blog

notes on distributed systems, infrastructure, and production engineering

home · github · rss

Short, practical writing on systems work: schedulers, data pipelines, observability, performance, infrastructure, and the tooling around it.

Broken Contracts Must Not Be Silent

An agent loop cannot safely recover from an internal event it never understood. Reject invalid events before they enter durable state.

A Harness Is Not a Leash

Agent safety is often designed as continuous operator control. A harness creates the conditions for safe autonomous work; a leash makes the operator part of every move.

The Client Is Not the Agent

A multi-client agent stays coherent when its runtime owns interaction semantics and every client renders the same contract.

A Profile Is Not a Preset

Agent profiles should compose an operating stance and communication style. They should not be opaque bundles that also select models, tools, and authority.

A Preference Is Not Permission

An agent profile can describe the work a user wants. It must not silently expand what the agent is authorized to do.

Discovery Is Not Enrollment

Finding a service on a local network establishes a route to a candidate. It does not establish the service's identity or authorize a client to use it.

mDNS Is for One Link

Multicast DNS lets devices resolve local names and discover services without a local DNS server. Its multicast design is useful on one link and a poor fit once discovery must span networks or enforce trust.

A Memory System Is an Admission Policy

palOMine started as a fact store with decay and contradiction handling. Making it work required deciding what sources could produce facts, what evidence they carried, and what the next request should retrieve.

The Goal Is Not to Catch Up

Being excellent without being the best is not a failure. A ranking can describe a gap without assigning the rest of us a lesser purpose.

Documentation Is a System Boundary

Documentation is not a record of what exists. It is the boundary that tells you what does not. Treating it as a contract changes what ships and what gets rejected.

Least Privilege Is an Operational Decision

Least privilege is often described as a security principle. It is usually treated like a technical checklist. Both descriptions miss the thing that actually determines how well it works in production.

Prompt, Context, and Memory Are Different Systems

Reliable agents do not solve continuity with one giant prompt. They separate instructions, working context, conversation history, and durable memory, then manage the boundaries between them.

A Benchmark Is a Contract

Cloudlight measures browser-local LLM readiness by constraining the workload and naming the limits of the evidence. That discipline matters more than another tokens-per-second number.

Deterministic Does Not Mean Predictable

LLMs generate text through repeated prediction. The calculation can be deterministic even when the finished answer remains unknown until it is produced.

The AI-Writing Tell Is That Nothing Was Said

People point to punctuation and vocabulary as evidence of AI writing. The deeper signal is polished prose that carries little meaning, an old human habit that models can reproduce at scale.

The Rubber Duck Can Use Tools Now

My wife used to wait until I was available when she needed technical help. Now she asks a smaller local model that has learned how she works and how to use the tools around her.

AI Can Improve the Result While Weakening the Thinking

AI can raise the quality of an artifact while quietly weakening the judgment that produced it. The risk is real, but the outcome depends on how the tool is used and which parts of the work we continue to own.

Inside the AI Harness

An AI harness is the runtime that turns a request into controlled and observable work. Following one failing test exposes the parts hidden behind the term.

Every Prompt Has a Training Cost

Prompt tokens are part of every training sequence. Reducing unnecessary context makes fine-tuning faster, cheaper, and easier to evaluate.

How the Model Knew What We Were Working On

A model can sound aware of ongoing work when retrieval finds the relevant memory and assembles it into the current context. A hybrid AST, syntax, and reranking path makes that retrieval faster and more precise.

Frontend Deployment Is Runtime Behavior

Frontend hosting becomes part of application behavior when it determines page speed, streaming, runtime configuration, and the shape of production failures.

From Backfills to Live Streams

Batch and live market-data paths share domain concepts while relying on different runtime contracts for reconstruction, continuity, and failure recovery.

The Market Data App Became a Distributed System

A market-data product becomes a distributed system when it starts depending on durable coordination, replayable work, live state, deployment boundaries, and explanations operators can trust.

Testing Strategy in the AI Era

When code volume outpaces human review capacity, testing strategy has to change. The old model doesn't scale.

Using Conway's Law Deliberately

Conway's Law can be used deliberately when team structure, ownership, and communication paths are part of the architecture discussion.

The Best AI Wins End in Automation

A lot of useful AI work should not stay AI work forever. Once the task resolves into explicit, repetitive, mechanically checkable rules, the better runtime is usually deterministic automation.

Agents Are Permission Systems

The hard part of deploying agents is not mostly reasoning quality. It is deciding what they are allowed to do, when they must ask, what they must prove before acting, and how you recover when they are wrong.

Tactical Skill Is Not Enough

AI is compressing the market value of tactical execution. The people who stay relevant will be the ones who learn to direct the work, judge the output, and keep building real mastery instead of outsourcing the reps that create it.

AI Review Is Not a New Discipline

A lot of the panic around reviewing AI output treats it like a new burden. It isn't. If you've spent years reviewing other people's code, libraries, and infrastructure decisions, you already know the job. AI just makes the need for that judgment harder to ignore.

Ownership Is Not a File

You can own a service and still abdicate responsibility for the outcomes it produces. Real ownership means caring about the consequences of your work, not just the artifacts.

The Face Changed, the Dependency Didn't

AI outages feel like a new kind of problem. They aren't. They're the same dependency risk we've always had, wearing a new label. The question that matters isn't whether AI is reliable. It's what happens to your business when the dependency disappears.

When Intelligence Becomes a Commodity

For years software companies built moats around technology that was hard to build. AI is dissolving that assumption. When intelligence is rented instead of owned, the model stops being a moat and becomes infrastructure. The durable advantage is whatever is harder to copy than intelligence itself.

The Model Myth: Why the Best Model Isn't the Winner

There's a growing consensus that whoever wields the best model wins the AI revolution. I don't buy it. Code is becoming a commodity, and when output is free its value approaches zero. The advantage was never the model. It's the understanding the model can't supply.

The Goal Is Not To Be Needed

For years I thought the goal was to become the person everyone depends on. It isn't. If the system only works because you're there, you haven't built leverage, you've become its failure mode.

The Most Expensive Bugs Never Reach Production

The bugs that bankrupt projects aren't runtime bugs. They're decisions. Nobody files a ticket for the wrong database or the wrong ownership model, and nobody sees a stack trace, yet they cost more than every syntax error combined.

Code Review Isn't Dying. It's Moving Upstream.

People keep saying AI is killing code review. It isn't. The cheap part is being automated and the expensive part is being pushed up to where it always mattered most: the design, the boundary, the conversation before anyone opened an editor.

Architecture Review > Code Review

Code review catches the bug in the function. Architecture review catches the bug in the plan, and the second one is almost always the one that sinks you.

You Can't Prove the Bug Isn't There

A missing constraint sat in Zcash's Orchard pool for four years, surviving in-depth human audits. Four days after a new AI model shipped, an automated audit found it. When discovery accelerates like that, the security advantage stops being perfect code and becomes the speed from "found" to "users protected."

Experience Is Compression

Senior engineers aren't valuable because they know more. They're valuable because they've already seen the movie, and they recognize the failure mode before it finishes introducing itself.

Architecture Is What Happens After Success

Most systems don't fail when they get traffic. They fail when they get successful, because success arrives with everything that was easy to ignore on launch day.

The Most Dangerous Engineer

The most dangerous engineer on a team isn't the junior. It's the one who stopped being curious, because everything underneath them keeps moving whether they keep learning or not.

Distributed Systems Are Mostly Apologies

A distributed system is a collection of carefully managed disappointments. The engineering isn't avoiding failure, it's choosing which failures you're willing to tolerate.

The Code Looks Fine. That's the Problem.

AI made the obvious mistakes rare and the expensive ones invisible. Code review didn't get easier. It moved up the stack, from implementation to judgment.

"It Works" Is Not "It's Ready"

AI is great at getting an app running. It is not the same as getting it ready for real users, real payments, and real data. Here is where the gap hides.