Posts on Programmer.ie: Modern AI programming

Build a Production AI Agent From First Principles: The Complete Reference Architecture

Sun, 09 Aug 2026 16:09:00 +0100

Build a Production AI Agent From First Principles: The Complete Reference Architecture

We have spent this series adding mechanisms only when a specific failure demanded them.

We started with a model call.

Then we added candidate generation, critique, planning, tool use, memory, search and verification.

Then the system stopped looking like a clever prompt.

It started looking like software.

Then distributed systems problems arrived:

duplicate work,
retries,
leases,
fencing,
backpressure,
dependency failure,
behavioral drift,
release compatibility,
replay,
incident forensics,
SLOs,
authority,
competence,
capability acquisition,
placement,
handoff,
stale state,
stale intent,
commitments,
durable workflows,
transaction recovery,
trust boundaries,
multi-agent coordination,
and finally an explicit control plane.

At this point the architecture is complete enough that adding another isolated mechanism would make the series worse rather than better.

Advanced Agents From First Principles 24: How Do You Release Agent Behavior Safely? Add Behavioral Contracts, Compatibility Checks and Promotion Gates

Sun, 09 Aug 2026 12:09:00 +0100

A model change can pass health checks and still break your agent.

A prompt change can preserve output schema and still change which tools the agent chooses.

A router change can improve average cost and silently starve a specialist that is essential for one high-risk workload.

A memory migration can keep every row intact and still change which memories are retrieved.

A verifier upgrade can make every dashboard greener while making the system less trustworthy.

Advanced Agents From First Principles 23: Your Infrastructure Is Healthy. Why Is the Agent Getting Worse? Detect Behavioral Drift and Roll Back Safely

Sun, 09 Aug 2026 12:00:00 +0100

Your Infrastructure Is Healthy. Why Is the Agent Getting Worse?

Your dashboards are green.

The model endpoint is responding.

The browser workers are alive.

The database is healthy.

The queue is draining.

The verifier service is up.

Latency has not exploded.

There are no obvious exceptions.

And yet the agent is getting worse.

It fixes fewer bugs.

It retrieves weaker evidence.

It escalates to expensive models more often.

It chooses the wrong tools more frequently.

Advanced Agents From First Principles 22: What Happens When One Dependency Starts Failing? Add Circuit Breakers, Bulkheads and Graceful Degradation

Sun, 09 Aug 2026 11:26:00 +0100

What Happens When One Dependency Starts Failing?

An advanced agent platform can be working perfectly and still collapse.

Not because the planner became confused.

Not because the router chose the wrong model.

Not because MCTS explored the wrong branch.

Because one dependency became unhealthy.

Maybe:

the frontier model starts returning 503s,
the browser pool starts timing out,
the embedding service slows from 80 ms to 8 seconds,
the verifier database starts dropping connections,
the search API starts rate limiting,
a sandbox cluster stops accepting jobs,
or an external provider is technically up but so slow that every request consumes a worker for minutes.

Then the retries begin.

Advanced Agents From First Principles 21: What Happens When Too Many Agents Compete for the Same Resources? Add Admission Control, Quotas and Backpressure

Sun, 09 Aug 2026 11:21:00 +0100

What Happens When Too Many Agents Compete for the Same Resources?

A single agent can look healthy in isolation.

It gets a request.

It calls a model.

It launches a few search branches.

It opens a browser.

It runs tests.

It asks a verifier to check the result.

Everything works.

Then production traffic arrives.

Ten agents start at once.

Then fifty.

Then five hundred.

Now every agent still has a perfectly reasonable local plan.

Advanced Agents From First Principles 20: Can Your Agent Coordinate Across Machines Without Duplicating Work? Use Leases, Idempotency and Fencing

Sun, 09 Aug 2026 11:13:00 +0100

Can Your Agent Coordinate Across Machines Without Duplicating Work?

A single-process agent can already be complicated.

It can plan.

It can search.

It can launch speculative branches.

It can cancel losing work.

It can verify outcomes.

Then you move that work onto multiple workers.

Now a new class of failure appears.

Two workers both believe they own the same task.

One worker pauses for thirty seconds.

Another worker assumes it died and takes over.

Advanced Agents From First Principles 19: Can Your Agent Explore in Parallel Without Creating Chaos? Use Speculative Execution and Early Cancellation

Sun, 09 Aug 2026 11:10:00 +0100

Advanced Agents From First Principles 19: Can Your Agent Explore in Parallel Without Creating Chaos? Use Speculative Execution and Early Cancellation

A production agent often has more than one useful thing it could do next.

It could:

inspect repository state,
run a targeted test,
retrieve documentation,
ask a second model to critique a candidate,
generate an alternative implementation,
probe an API,
inspect a deployment,
or verify an invariant.

If those actions are independent, executing them one by one can be needlessly slow.

Advanced Agents From First Principles 18: What Should Your Agent Observe Next? Use Expected Value of Information

Sun, 09 Aug 2026 11:06:00 +0100

What Should Your Agent Observe Next?

Your agent is uncertain.

That does not tell you what to do.

In the previous post we split uncertainty into operational categories:

interpretation uncertainty,
evidence uncertainty,
route uncertainty,
state uncertainty,
tool uncertainty,
candidate uncertainty,
verification uncertainty.

That is already better than one generic confidence score.

But it still leaves a harder question:

Which piece of information is worth buying next?

Suppose a coding agent is trying to fix a failing test.

Advanced Agents From First Principles 17: What Is Your Agent Actually Uncertain About?

Sun, 09 Aug 2026 11:02:00 +0100

What Is Your Agent Actually Uncertain About?

An agent reaches a difficult point in a task.

It is not sure what to do next.

A common implementation responds like this:

uncertain
   ↓
call the model again
   ↓
still uncertain
   ↓
call a stronger model
   ↓
still uncertain
   ↓
search more

That is not a reasoning strategy.

It is a spending strategy.

The system is using more computation without identifying what information is actually missing.

Advanced Agents From First Principles 16: Where Should an Agent Spend Its Compute? Build a Dynamic Budget Scheduler

Sun, 09 Aug 2026 10:53:00 +0100

Where Should an Agent Spend Its Compute?

A production agent has a budget whether you designed one or not.

Every model call costs something.

Every search node costs something.

Every tool invocation costs something.

Every verifier costs something.

Every retry adds latency.

Every escalation to a stronger model spends money and time that could have been used somewhere else.

The naive architecture gives every subsystem its own fixed limit:

MAX_STEPS = 20
MAX_SEARCH_NODES = 32
MAX_CRITIC_CALLS = 3
MAX_RETRIES = 4
MAX_VERIFIER_CALLS = 2

That looks safe.

Advanced Agents From First Principles 15: How Do You Optimize an Agent Policy Without Turning It Into Another Black Box?

Sun, 09 Aug 2026 10:49:00 +0100

How Do You Optimize an Agent Policy Without Turning It Into Another Black Box?

By now our advanced agent can do a lot.

It can:

route tasks to different models or specialists,
decide whether to search,
choose a search budget,
decide when to escalate,
invoke critics,
retry or recover,
stop when evidence is strong enough,
learn from verified production trajectories,
and trace the decisions that produced each outcome.

That creates a new problem.

Advanced Agents From First Principles 14: Can Your Agent Learn From Its Own Trajectories Without Learning the Wrong Lessons?

Sun, 09 Aug 2026 10:33:00 +0100

An advanced agent now leaves behind something extremely valuable:

evidence.

Not merely chat history.

Not merely model outputs.

Not merely traces.

A sufficiently instrumented system can record:

what state it was in,
what alternatives it considered,
which route it selected,
what branches it pruned,
which model or specialist it escalated to,
which tools it called,
which critic changed the answer,
what verification evidence was produced,
how much compute was spent,
and whether the final result actually passed.

That immediately suggests a tempting idea:

Advanced Agents From First Principles 13: How Do You Debug an Agent That Made the Wrong Decision? Add Trajectory Observability

Sun, 09 Aug 2026 10:18:00 +0100

An advanced agent fails.

You look at the final answer.

It is wrong.

So you inspect the prompt.

The prompt looks reasonable.

You inspect the model response.

That also looks reasonable.

But somewhere between the original request and the final result the system:

chose the wrong specialist,
pruned the branch that contained the right solution,
trusted a critic that was wrong,
escalated to an expensive model unnecessarily,
failed to escalate when it should have,
retrieved stale memory,
spent most of its budget exploring duplicates,
accepted a weak verifier signal,
retried the same strategy under a different name,
or transformed a local success into a global failure.

The final answer does not tell you which one happened.

Advanced Agents From First Principles 12: Is Your Advanced Agent Actually Better? Benchmark It Under Equal Budgets

Sun, 09 Aug 2026 10:10:00 +0100

Is Your Advanced Agent Actually Better? Benchmark It Under Equal Budgets

You replace one model call with eight.

Success rises from 62% to 74%.

Great.

Except the new system used:

eight times the inference,
three extra judges,
two rounds of critique,
a larger context,
a stronger verifier,
and several times the latency.

Did the architecture improve?

Or did you just buy more attempts?

This is one of the easiest mistakes to make in advanced agent engineering.

Advanced Agents From First Principles 11: Which Advanced Agent Architecture Should You Use? A Practical Selection Guide

Sun, 09 Aug 2026 09:20:00 +0100

Which Advanced Agent Architecture Should You Use?

You now have too many options.

That is a better problem than having none.

But it is still a problem.

You can add:

self-consistency,
Tree of Thoughts,
beam search,
Monte Carlo Tree Search,
evolutionary search,
specialist routing,
planner/executor/critic separation,
multi-agent debate,
adaptive policies,
learning from previous runs,
or a mixture-of-agents runtime that chooses among several of them.

The temptation is to combine everything.

Advanced Agents From First Principles 08: Is Your Agent Spending the Same Compute on Every Task? Build Adaptive Agents That Escalate Only When Needed

Sun, 09 Aug 2026 00:00:00 +0000

Build adaptive agent runtimes that start cheap, measure uncertainty and failure, and escalate selectively into deeper reasoning, more samples, search, stronger models or specialist review only when the evidence justifies it.

Advanced Agents From First Principles 25: Can You Reproduce an Agent Run Months Later? Add Deterministic Replay and Provenance

Sun, 09 Aug 2026 00:00:00 +0000

A production agent fails on Tuesday.

You inspect it on Wednesday and cannot reproduce the failure.

Three weeks later someone asks a harder question:

What exactly did this agent see, which release was running, which tools were called, which evidence was used, and why did the verifier accept the result?

If the answer is “we have some logs”, you do not yet have reproducibility.

You have fragments.

Advanced agents accumulate hidden variability quickly:

Advanced Agents From First Principles 26: Why Did the Agent Fail? Build an Incident Forensics Pipeline

Sun, 09 Aug 2026 00:00:00 +0000

A practical incident-forensics workflow for advanced agents: reconstruct the run, find the earliest divergence, distinguish root cause from downstream symptoms, measure blast radius, and prove that a remediation would have prevented the incident.

Advanced Agents From First Principles 27: How Reliable Does an Agent Need to Be? Define SLOs and Error Budgets

Sun, 09 Aug 2026 00:00:00 +0000

A practical reliability framework for advanced agents: define verified-success SLOs, false-success ceilings, UNKNOWN budgets, latency and cost targets, then use error-budget burn to decide when to ship capability and when to stop and harden the system.

Advanced Agents From First Principles 28: Where Should You Spend the Next Engineering Hour? Prioritize Reliability by Risk and Expected Return

Sun, 09 Aug 2026 00:00:00 +0000

A practical framework for deciding where to spend the next engineering hour in an advanced-agent system: rank remediation by expected reduction in verified reliability loss, severity, recurrence, blast radius, confidence and implementation cost.

Advanced Agents From First Principles 29: When Should an Agent Stop and Ask a Human? Design Authority Boundaries and Escalation

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for agent authority boundaries: decide what an agent may do autonomously, when it must escalate, what evidence a human reviewer needs, and how to avoid turning human approval into rubber-stamping.

Advanced Agents From First Principles 30: Is This Task Outside Your Agent’s Competence? Build Competence Envelopes and OOD Detection

Sun, 09 Aug 2026 00:00:00 +0000

A practical framework for competence envelopes in production agents: distinguish uncertainty from lack of validated competence, detect out-of-distribution tasks, contract authority when evidence is weak, and expand autonomy only through measured evidence.

Advanced Agents From First Principles 31: How Can an Agent Learn New Capabilities Without Expanding Its Own Authority? Use Sandboxed Capability Acquisition

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for sandboxed capability acquisition: let agents explore tasks outside their validated competence envelope, accumulate externally verified evidence, and propose capability expansion without ever granting themselves production authority.

Advanced Agents From First Principles 32: Which Capabilities Are Actually Worth Building? Design a Capability Portfolio

Sun, 09 Aug 2026 00:00:00 +0000

A practical framework for deciding which agent capabilities are worth acquiring: rank missing capabilities by user value, verifier availability, reliability risk, acquisition cost, maintenance burden, and the quality of human or deterministic alternatives.

Advanced Agents From First Principles 33: Which Shared Components Actually Unlock More Capability? Build a Capability Dependency Graph

Sun, 09 Aug 2026 00:00:00 +0000

A practical capability-dependency architecture for advanced agents: identify shared primitives that unlock many capabilities, quantify leverage, expose correlated-failure hotspots, and invest in platform components without creating hidden systemic risk.

Advanced Agents From First Principles 34: Where Should This Task Actually Run? Build Capability-Aware Placement Across Models, Providers and Resource Pools

Sun, 09 Aug 2026 00:00:00 +0000

A practical placement architecture for advanced agents: route work across local and frontier models, providers, regions, GPUs, browser pools and specialist runtimes using demonstrated competence, verifier availability, policy constraints, health, cost and latency rather than model prestige.

Advanced Agents From First Principles 35: How Do You Move a Running Agent Between Workers Without Losing Meaning? Build Portable Execution State and Safe Handoff

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for portable agent execution state: checkpoint long-running runs, transfer ownership safely across workers and providers, preserve evidence and authority, and reject migrations that cannot be proven compatible.

Advanced Agents From First Principles 36: Is Your Agent Acting on Stale State? Build Temporal Consistency, Freshness Budgets and Conflict Detection

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for keeping long-running agents from acting on stale assumptions: classify state by freshness, track version vectors, detect conflicts, revalidate before consequential actions, and force replanning when the world has changed underneath the run.

Advanced Agents From First Principles 37: Is Your Agent Still Solving the Right Task? Build Intent Versioning, Supersession and Cancellation

Sun, 09 Aug 2026 00:00:00 +0000

A production architecture for intent versioning, supersession and cancellation in long-running agents: stop obsolete work, preserve committed effects, reconcile partial actions, and prevent stale goals from retaining authority.

Advanced Agents From First Principles 38: A Plan Is Not a Commitment — Model Goals, Commitments and Executable Work

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for separating goals, plans, commitments, tasks and actions in long-running agents so replanning, cancellation, handoff and external obligations remain correct.

Advanced Agents From First Principles 39: How Do You Make an Agent Survive for Days? Build Durable Long-Running Workflows

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for long-running agents: keep workflow state durable while treating models and workers as disposable, with explicit waits, retries, timers, human approvals, checkpoints, commitments, cancellation and replay.

Advanced Agents From First Principles 40: Your Agent Changed the World. What Happens When Step Two Fails? Build Transactions, Compensation and Reconciliation

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for agent workflows that span systems without a global transaction: classify side effects, prepare carefully, commit with identity, verify externally, compensate when possible, reconcile ambiguity, and never pretend rollback is free.

Advanced Agents From First Principles 41: What Should Your Agent Trust? Build Explicit Security and Trust Boundaries

Sun, 09 Aug 2026 00:00:00 +0000

A practical security architecture for production agents: separate data from authority, classify trust, scope credentials and capabilities, preserve provenance, isolate generated code, resist prompt injection, and keep security-critical decisions outside model control.

Advanced Agents From First Principles 42: How Do Multiple Agents Coordinate Without Becoming a Distributed Argument?

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for multi-agent coordination: explicit ownership, delegation, contracts, commitment transfer, shared intent, evidence provenance, conflict handling, deadlock prevention, and independent verification instead of agents merely chatting until they agree.

Advanced Agents From First Principles 43: Who Controls the Agent? Build an Explicit Agent Control Plane

Sun, 09 Aug 2026 00:00:00 +0000

A production-agent architecture that separates control-plane policy from execution-plane reasoning: intent, competence, authority, placement, budgets, reliability, releases, security and escalation remain enforceable outside the model.

You Probably Don't Need All of This: Build the Minimum Production Agent Architecture

Sun, 09 Aug 2026 00:00:00 +0000

You Probably Don’t Need All of This

Over the previous forty-five steps, we built almost every major mechanism you might need in a serious agent platform.

Search.

Critique.

Planning.

Memory.

Verification.

Distributed execution.

Leases.

Fencing.

Backpressure.

Behavioral releases.

Replay.

Incident forensics.

SLOs.

Competence envelopes.

Authority boundaries.

Capability portfolios.

Placement.

Portable execution state.

Temporal consistency.

Intent versioning.

Commitments.

Durable workflows.

Transaction recovery.

Security boundaries.

Multi-agent coordination.

An explicit control plane.

And finally, in Step 44, we assembled those ideas into a complete reference architecture for a production AI agent.

Advanced Agents From First Principles 10: Are You Combining Every Agent Technique Into One Monster? Build a Mixture-of-Agents Runtime

Sun, 09 Aug 2026 00:25:00 +0100

You have a working agent.

Then you add retrieval.

Then memory.

Then Best-of-N.

Then critique and revision.

Then Tree of Thoughts.

Then MCTS.

Then specialist models.

Then adversarial review.

Then a planner, executor, critic and verifier.

Then a stronger model for hard cases.

Eventually the architecture starts to look like this:

request
  ↓
planner
  ↓
retrieval
  ↓
reasoning
  ↓
Best-of-N
  ↓
critic
  ↓
Tree of Thoughts
  ↓
MCTS
  ↓
frontier model
  ↓
second critic
  ↓
verifier

Every mechanism may have been individually reasonable.

Advanced Agents From First Principles 09: Can Your Agent Actually Learn From Previous Runs?

Sun, 09 Aug 2026 00:19:00 +0100

Can Your Agent Actually Learn From Previous Runs?

A production agent can execute the same class of task hundreds or thousands of times.

It can see the same failure repeatedly.

It can discover the same workaround repeatedly.

It can call the same expensive model repeatedly.

And still behave as if every task is the first one it has ever seen.

That is not necessarily a memory problem.

It may already have excellent memory.

Advanced Agents From First Principles 06: Does One Agent Plan, Execute and Judge Its Own Work? Build a Planner-Executor-Critic Architecture

Sat, 08 Aug 2026 23:49:00 +0100

Does One Agent Plan, Execute and Judge Its Own Work? Build a Planner-Executor-Critic Architecture

A single model can often do all of these things:

understand a task,
decide what to do,
execute a tool call,
inspect the result,
critique its own work,
decide whether it succeeded,
and produce the final answer.

That is convenient.

It is also a dangerous concentration of responsibilities.

If the same component creates the plan, executes it, explains why the result is good, and decides whether the job is complete, then failures become difficult to localize.

Advanced Agents From First Principles 05: Is One Model Doing Everything? Build a Mixture of Experts at the Agent Level

Sat, 08 Aug 2026 23:41:00 +0100

A common agent architecture starts simply:

request
   ↓
model
   ↓
action

That simplicity is valuable.

It should be your default.

But eventually you may notice something strange.

The same model is being asked to do everything:

classify the task,
search documentation,
reason about code,
write SQL,
review a patch,
summarize logs,
judge another model,
decide whether a deployment is safe,
and answer simple questions that did not require an expensive model in the first place.

At that point the problem may no longer be:

Advanced Agents From First Principles 04: Does Your Agent Prune Good Ideas Too Early? Use Monte Carlo Tree Search for Long-Horizon Reasoning

Sat, 08 Aug 2026 23:37:00 +0100

A common failure in search-based agents is easy to miss.

The agent generates several plausible branches.

It scores them.

One branch looks weak.

So the runtime prunes it.

Later, you discover that the discarded branch was the only one that could have reached the correct solution.

The problem was not generation.

The problem was not necessarily the model.

The problem was search allocation.

The agent spent too much compute exploiting what looked good early and too little compute exploring alternatives whose value only became visible later.

Advanced Agents From First Principles 03: Does Your Agent Commit to a Bad Reasoning Path Too Early? Build a Tree of Thoughts

Sat, 08 Aug 2026 23:25:00 +0100

A reasoning agent can fail even when every individual step looks plausible.

The problem is often not that the model cannot produce a good line of reasoning.

The problem is that it commits too early.

It chooses one interpretation, one hypothesis, one plan, or one next step and then spends the rest of the run trying to make that decision work.

That gives us a common failure pattern:

problem
  ↓
first plausible thought
  ↓
second thought conditioned on the first
  ↓
third thought conditioned on both
  ↓
...
  ↓
confident answer built on an early mistake

If the first branch was wrong, every later step inherits the error.

Advanced Agents From First Principles 02: Why Does My Reasoning Agent Give a Different Answer Every Time? Use Self-Consistency Without Confusing Consensus With Truth

Sat, 08 Aug 2026 22:44:00 +0100

A reasoning agent gives you one answer.

You run it again.

It gives you another.

You change nothing important:

same task,
same tools,
same model family,
same broad context.

Yet the result changes.

That is not necessarily a bug.

A probabilistic model is allowed to produce more than one plausible trajectory.

The engineering question is different:

How should an agent system use that variation?

One common answer is self-consistency.

Advanced Agents From First Principles 01: Does Your AI Agent Fail on Complex Reasoning Tasks? Treat Chain of Thought as Computation, Not Proof

Sat, 08 Aug 2026 22:35:00 +0100

Most developers first encounter chain of thought as a prompting trick:

Think step by step.

That framing is too shallow for agent engineering.

For an advanced agent, the useful idea is not that the model should produce a long explanation. The useful idea is that a difficult task may benefit from intermediate computational state before the system commits to an action or answer.

That is a very different claim.

A reasoning trace can help a system decompose a problem, preserve intermediate conclusions, identify missing information, decide what to verify next, and expose places where search or tools should be used.

Advanced Agents From First Principles 00: When Should You Use an Advanced Agent Architecture?

Sat, 08 Aug 2026 22:27:00 +0100

Advanced Agents From First Principles 00: When Should You Use an Advanced Agent Architecture?

You built an agent.

It can:

call tools,
maintain state,
plan,
revise its own work,
search over alternatives,
remember useful information,
and verify whether the requested outcome actually happened.

Now the temptation begins.

You add another model.

Then a critic.

Then a planner.

Then a judge.

Then a router.

Then three specialist agents.

Then a tree search.

Agents From First Principles 09: AI Agent Says It Worked When It Didn’t? Verify the Result Outside the LLM

Sat, 08 Aug 2026 17:31:00 +0100

An AI agent says:

Done. The task is complete.

That sentence is almost worthless.

The agent may have:

edited the wrong file,
changed the right file incorrectly,
skipped part of the request,
broken another subsystem,
failed to save its work,
misread a tool result,
passed a stale test,
inspected the wrong environment,
or simply decided that its own answer looked convincing.

The central problem is simple:

The system that produced the answer should not be the only system deciding whether the answer is correct.

Agents From First Principles 08: AI Agent Picks the First Solution? Add Search Instead of One-Shot Generation

Sat, 08 Aug 2026 17:26:00 +0100

An AI agent often fails for a surprisingly ordinary reason:

it commits too early.

It finds one plausible next action, follows it, and then spends the rest of the run trying to make that first choice work.

That can look intelligent because the agent keeps reasoning, calling tools, revising plans, and explaining itself.

But underneath, the trajectory may be almost completely determined by an early mistake.

A coding agent chooses the wrong implementation strategy and spends twenty tool calls repairing it.

Agents From First Principles 07: AI Agent Forgets Previous Work? Add Working, Semantic and Episodic Memory

Sat, 08 Aug 2026 17:14:00 +0100

AI Agent Forgets Previous Work? Add Working, Semantic and Episodic Memory

An agent can use the right model, call the right tools, execute the right plan, and still behave as if nothing that happened five minutes ago matters.

You see the symptoms quickly:

it re-reads files it already inspected;
it repeats research it already completed;
it asks for information the user already supplied;
it forgets why a previous approach failed;
it loses decisions made earlier in a long task;
it treats every new run as if the system has never seen the problem before;
it retrieves an old answer and treats it as current truth;
it fills the prompt with so much history that the useful information is buried.

The usual response is:

Agents From First Principles 06: AI Agent Chooses the Wrong Tool? Design Better Tool Interfaces, Schemas and Routing

Sat, 08 Aug 2026 17:09:00 +0100

An agent can have a perfectly capable model and still behave badly because its tools are badly designed.

This is one of the most common agent failures in production:

user goal
   ↓
agent
   ↓
wrong tool
   ↓
wrong action

The model may understand the task.

The agent may have enough context.

The problem is that the action space is ambiguous.

If two tools overlap, their descriptions are vague, their schemas are huge, or their results are difficult to interpret, the model has to guess.

Agents From First Principles 05: AI Agent Gets Stuck in a Loop? Add State, Feedback and Stopping Conditions

Sat, 08 Aug 2026 16:56:00 +0100

An AI agent that keeps calling the same tool, revisiting the same page, rewriting the same file, or repeatedly saying “I’ll try again” is not displaying persistence.

It is displaying a control-flow bug.

This is one of the most common failure modes in agent software because the basic loop is deceptively simple:

observe
  ↓
decide
  ↓
act
  ↓
observe
  ↓
repeat

The problem is hidden inside the final word.

Agents From First Principles 04: AI Agent Fails on Multi-Step Tasks? Separate Planning From Execution

Sat, 08 Aug 2026 16:35:00 +0100

A surprising number of agent failures are not really model failures.

The model may be perfectly capable of writing each individual step. The failure happens because the system tries to decide what to do and do it at the same time.

That works for simple tasks:

question
  ↓
model
  ↓
answer

It becomes fragile when success depends on several ordered actions:

goal
  ↓
step 1
  ↓
step 2
  ↓
step 3
  ↓
verification

A useful next step in agent design is therefore to separate two jobs:

Agents From First Principles 03: AI Agent Keeps Making the Same Mistake? Add a Critique-and-Revision Loop

Sat, 08 Aug 2026 16:23:00 +0100

An AI agent can fail in a particularly frustrating way: it produces an answer that is almost right, you ask it to improve the answer, and it produces another answer with the same underlying defect.

Sometimes the wording changes. Sometimes it adds more explanation. Sometimes it becomes longer and more confident. But the important mistake survives.

That usually means the system is doing this:

prompt
  ↓
model
  ↓
answer

or this:

Agents From First Principles 02: AI Agent Gives Inconsistent Answers? Generate Multiple Candidates and Rank Them

Sat, 08 Aug 2026 15:54:00 +0100

One of the first things you notice when you build anything around a large language model is that the same prompt does not always produce the same quality of answer.

Sometimes the first response is excellent.

Sometimes it is merely acceptable.

Sometimes it misses the point entirely.

That creates a very common agent-engineering question:

If the model is inconsistent, should the agent trust the first answer it gets?

Often, no.

AI Agent Returning Invalid Tool Calls? How to Validate LLM Actions

Sat, 08 Aug 2026 15:46:00 +0100

If your agent sometimes invents a tool name, omits a required argument, returns malformed JSON, or produces an action that looks plausible but cannot actually be executed, the problem is usually not “the agent is dumb.”

The problem is that raw language-model output has been allowed to cross directly into execution.

That boundary is too weak.

The simplest useful agent architecture is not:

prompt
  ↓
model
  ↓
execute whatever came back

It is:

Agents From First Principles 00: What Is an Agent, Really?

Sat, 08 Aug 2026 15:40:00 +0100

What Is an Agent, Really?

This is the first post in Agents From First Principles.

It follows two earlier series.

In PyTorch: Zero to Hero, we worked upward from tensors, autograd and neural-network building blocks until we could build a small language model ourselves.

In Models From First Principles, we moved one level higher. We looked at how learned components can be composed into scorers, value models, policy heads, recurrent models, hierarchical models and compact recursive systems.

Models From First Principles 08: Which Model Should You Use? MR.Q, EBT, SICQL, HRM, Tiny and PACS Compared

Sat, 08 Aug 2026 15:11:00 +0100

Which Model Should You Use? MR.Q, EBT, SICQL, HRM, Tiny and PACS Compared

This is the final post in Models From First Principles.

The earlier posts asked a sequence of architectural questions:

how do we score a context-response pair?
when is one scalar no longer enough?
when should Q, V and policy become explicit components?
when is one forward pass insufficient?
when does recurrence help?
when does hierarchy help?
when is a smaller recursive model a better trade-off?
when should attention or a sparse autoencoder be added?
when should we change the optimizer rather than the model?

This post asks the question that matters when building a real system:

Models From First Principles 07: PACS — Building an Optimizer From Gradient Statistics

Sat, 08 Aug 2026 15:05:00 +0100

PACS — Building an Optimizer From Gradient Statistics

So far in Models From First Principles, every post has asked some version of the same question:

What should the model compute?

MR.Q gave us a scalar quality estimate.

EBT split one shared representation into Q, V and Policy.

SICQL made those heads explicit, replaceable components.

HRM introduced repeated computation over fast and slow latent states.

Tiny compressed iterative refinement into one recursive latent state.

Models From First Principles 06: Inside Tiny — Residual Blocks, Attention and Sparse Autoencoders

Sat, 08 Aug 2026 15:00:00 +0100

Inside Tiny: Residual Blocks, Attention and Sparse Autoencoders

In the previous post, we built a compact recursive model around one idea:

context + candidate + latent state
              ↓
          projection
              ↓
         reusable core
              ↓
       proposed update
              ↓
      z ← z + α · update
              ↓
            repeat

That architecture looked more sophisticated than MR.Q, EBT or SICQL because it introduced recurrence.

But the central idea of this series is that a model stops looking mysterious when we keep opening it.

Models From First Principles 05: Tiny — Recursive Reasoning With a Small Neural Network

Sat, 08 Aug 2026 14:55:00 +0100

Tiny — Recursive Reasoning With a Small Neural Network

The previous post introduced a much more ambitious architecture.

Instead of taking one representation and predicting from it once, the Hierarchical Reasoning Model repeatedly updated two latent states:

input
  ↓
low-level state
  ↓ ↓ ↓
high-level state
  ↓
repeat

That gave us something genuinely new:

computation could continue without adding a new set of parameters for every step.

Models From First Principles 04: HRM — Hierarchical Reasoning With Fast and Slow Recurrent State

Sat, 08 Aug 2026 14:48:00 +0100

HRM — Hierarchical Reasoning With Fast and Slow Recurrent State

The previous models in this series were mostly one-pass models.

MR.Q took two embeddings and produced one score.

EBT kept the same basic structure but added several heads.

SICQL made those heads explicit components.

The architecture grew, but the shape of the computation was still familiar:

input
  ↓
encoder
  ↓
representation
  ↓
heads
  ↓
outputs

HRM changes the question.

Models From First Principles 03: SICQL — Building a Model From Q, V and Policy Networks

Sat, 08 Aug 2026 14:44:00 +0100

SICQL — Building a Model From Q, V and Policy Networks

In the previous post we took the MR.Q idea and expanded it into something richer.

Instead of asking one question of a shared representation, EBT asked several:

How good is this state-action pair?      -> Q
How good is the state more generally?    -> V
What action should be preferred?         -> Policy
How much better is Q than V?              -> Advantage

That already gave us a more expressive system.

Models From First Principles 02: EBT — From One Score to Q, V, Policy and Advantage

Sat, 08 Aug 2026 14:39:00 +0100

EBT — From One Score to Q, V, Policy and Advantage

In the previous post we built MR.Q: a small model that takes a context embedding and a response embedding, combines them, and predicts one scalar.

That architecture is useful because it is brutally simple:

context embedding
        +
response embedding
        ↓
     encoder
        ↓
   representation z
        ↓
    predictor
        ↓
      Q value

But one scalar eventually becomes restrictive.

Models From First Principles 01: MR.Q — Building a Neural Quality Model From Two Embeddings

Sat, 08 Aug 2026 14:33:00 +0100

MR.Q — Building a Neural Quality Model From Two Embeddings

In the previous post, we established the core idea behind this series:

A complicated model becomes understandable when you recursively decompose it into smaller models, blocks, layers and tensor operations.

Now we build the first real model.

Not a transformer.

Not a giant language model.

Not an agent.

A scorer.

We will take two embeddings:

context embedding
response embedding

combine them, encode the relationship between them, and predict one scalar:

Models From First Principles 00: The Model Inside the Model

Sat, 08 Aug 2026 14:27:00 +0100

The Model Inside the Model

This is the first post in Models From First Principles.

The previous PyTorch: Zero to Hero series worked from the bottom up.

We started with tensors.

Then gradients.

Then nn.Module.

Then data pipelines, convolution, attention, debugging, performance and finally a small GPT-style language model built from scratch.

That series answered:

What are the pieces?

This series asks a different question:

What happens when we start composing those pieces into increasingly sophisticated models?

PyTorch Zero to Hero 10: Build a Small GPT-Style Language Model From Scratch

Sat, 08 Aug 2026 14:03:00 +0100

Build a Small GPT-Style Language Model From Scratch in PyTorch

This is the final post in the PyTorch: Zero to Hero series.

We have spent the previous posts learning the machinery underneath PyTorch:

tensors and shapes;
autograd;
manual neural networks;
nn.Module and parameter registration;
DataLoader performance;
convolutional networks;
attention and masks;
training failures;
CUDA performance and torch.compile.

Now we put it together.

The goal is not to download a pretrained model.

PyTorch Performance Debugging: CUDA OOM, Slow Training, GPU Utilization and torch.compile

Sat, 08 Aug 2026 13:56:00 +0100

PyTorch: Zero to Hero — Step 09

At this point in the series, the model runs.

That does not mean it runs well.

A training loop can be correct and still waste most of the machine.

A model can fit in memory and still spend half its time waiting on synchronization.

A torch.compile call can make code faster, slower, or simply move the bottleneck somewhere else.

A CUDA out-of-memory error can be caused by the model, the optimizer, activations, fragmentation, a leaked reference, a larger batch, a longer sequence, or an innocent-looking tensor that was kept alive by Python.

PyTorch Model Not Learning? A Systematic Debugging Guide

Sat, 08 Aug 2026 13:51:00 +0100

PyTorch: Zero to Hero — Step 08

Your model runs.

The loss is finite.

Nothing crashes.

And it still does not learn.

This is one of the most frustrating states in machine learning because there is no stack trace telling you what is wrong.

The program is valid Python.

The tensors have legal shapes.

The GPU is busy.

The optimizer is stepping.

And the model is useless.

This post is a systematic way to debug that situation.

PyTorch Attention Shapes: Q, K, V, Multi-Head Attention Masks and Transformer Dimension Errors

Sat, 08 Aug 2026 13:30:00 +0100

PyTorch: Zero to Hero — Step 07

Attention code is where tensor-shape mistakes stop being annoying and start becoming architectural.

A CNN usually makes its dimensional assumptions fairly obvious. Attention does not.

A tensor that starts as:

(batch, sequence, embedding)

is projected into Q, K and V, split into heads, transposed, multiplied, masked, normalized, multiplied again, transposed again, concatenated and projected back to the embedding dimension.

A single bad view, transpose, mask shape or head calculation can produce anything from an immediate runtime error to a model that trains while attending to the wrong tokens.

PyTorch CNN Shape Errors: Conv2d Output Sizes, Channels, Flatten Bugs and How to Debug Them

Sat, 08 Aug 2026 13:26:00 +0100

PyTorch: Zero to Hero — Step 06

CNN code is usually easy to write.

CNN shape bugs are usually easy to create.

A typical failure looks like this:

RuntimeError: Given groups=1, weight of size [32, 3, 3, 3],
expected input[64, 224, 224, 3] to have 3 channels,
but got 224 channels instead

Or this:

RuntimeError: mat1 and mat2 shapes cannot be multiplied

Or worse: the model runs, but the dimensions are wrong in a way that silently damages the architecture.

PyTorch DataLoader Performance: num_workers, pin_memory, Prefetching and Why Your GPU Is Waiting

Sat, 08 Aug 2026 13:21:00 +0100

PyTorch: Zero to Hero — Step 05

A fast model with a slow input pipeline is still a slow training system.

One of the most common PyTorch performance failures looks like this:

GPU utilization: 20% → 95% → 10% → 90% → 15%

The model is not necessarily slow.

The GPU may simply be waiting for the next batch.

This article is about finding out where the wait is happening.

PyTorch nn.Module Explained: Missing Parameters, state_dict, Buffers and Registration Bugs

Sat, 08 Aug 2026 13:09:00 +0100

PyTorch: Zero to Hero — Step 04

In the previous post we built a neural network using raw tensors and autograd.

Now we are going to add the abstraction PyTorch expects almost every real model to use:

class Model(torch.nn.Module):
    ...

But this is not going to be a tour of nn.Module methods.

The useful question for programmers is:

What exactly does nn.Module register, track, move, save and expose — and how do those mechanisms break?

Build a Neural Network From Scratch in PyTorch Without nn.Module

Sat, 08 Aug 2026 12:59:00 +0100

PyTorch: Zero to Hero — Step 03

Most PyTorch tutorials begin with something like this:

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(2, 16),
    nn.ReLU(),
    nn.Linear(16, 2),
)

That is useful code.

It is also hiding almost everything interesting.

In this post we are going to build the same kind of neural network using ordinary PyTorch tensors.

No nn.Module.

No nn.Linear.

No torch.optim.Adam.

No optimizer.step().

We will manually create the parameters, write the forward pass, calculate the loss, call autograd, update the weights, zero the gradients, batch the data, evaluate the model and then compare the result with the idiomatic PyTorch version.

PyTorch Autograd Debugging: requires_grad, detach, backward() and NaN Gradients

Sat, 08 Aug 2026 12:55:00 +0100

PyTorch: Zero to Hero — Step 02

In the previous post we treated tensor shapes as a debugging problem rather than a mathematical vocabulary exercise.

We are going to do the same thing with autograd.

If you use PyTorch for any serious amount of time, you eventually see errors like:

RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

or:

RuntimeError: Trying to backward through the graph a second time...

or worse:

PyTorch Tensor Shapes: Broadcasting, Reshape, View, Permute and the Errors That Waste Your Time

Sat, 08 Aug 2026 12:45:00 +0100

PyTorch: Zero to Hero — Step 01

Most PyTorch bugs are not really “AI bugs”.

They are shape bugs.

You expected:

[batch, features]

but actually had:

[batch, sequence, features]

You expected two tensors to line up.

They broadcast instead.

You called view() after permute() and got a contiguity error.

You removed a dimension with squeeze() and accidentally removed the batch dimension too.

Or you reached the familiar message:

RuntimeError: The size of tensor a (...) must match the size of tensor b (...)

This article is about becoming dangerous enough with tensors that these errors stop being mysterious.

PyTorch Zero to Hero 00: What Are We Actually Doing?

Sat, 08 Aug 2026 12:40:00 +0100

PyTorch: Zero to Hero

This is Step 0 of a practical PyTorch series that starts with tensors and ends with building a small language model from scratch.

The goal is not to learn a collection of PyTorch commands.

The goal is to understand what the framework is doing well enough that the commands stop looking like magic.

By the end of the series we will have moved through tensors, gradients, neural networks, data pipelines, convolutional networks, attention, transformers, training, performance, and finally a small language model.

ZeroModel: Evidence Before Ambition

Sat, 08 Aug 2026 01:03:04 +0100

ZeroModel is an attempt to compile useful parts of intelligence into identified, portable, inspectable decision artifacts — and to preserve enough evidence around those artifacts that we can reproduce, challenge and replay what they do.

That sentence now covers considerably more ground than I expected when I started.

Start with the strangest result

One ZeroModel policy contains 112 states.

It can be executed in Python.

It can also be exported into a completely dependency-free Lua module.

Advanced Agents From First Principles 07: Do Your Agents Agree Too Easily? Use Adversarial Review and Multi-Agent Debate Without Confusing Debate With Truth

Sat, 08 Aug 2026 00:00:00 +0000

A multi-agent system can look sophisticated while every agent quietly repeats the same mistake.

That is one of the most dangerous failure modes in advanced agent architectures.

You ask one model to solve the problem.

Then you ask a second model to review it.

Then a third model judges the disagreement.

Three calls later, the system sounds more confident than before.

But if all three agents share the same blind spot, the extra machinery has not created independent evidence.

RELATE: Searching Embeddings by Relation, Not Just Similarity

Wed, 05 Aug 2026 23:24:45 +0100

Embeddings are everywhere in modern AI.

They power semantic search, retrieval-augmented generation, recommendations, clustering, duplicate detection, code search, memory systems, and many of the mechanisms through which an AI system decides what information is relevant.

Yet most systems interrogate embeddings in essentially the same way:

Take two vectors and calculate cosine similarity.

That is useful. But it also makes a strong assumption.

It assumes that the information we care about is expressed directly through the default geometry of the embedding space.

The Singularity Is Here

Wed, 29 Jul 2026 11:14:54 +0100

For decades, the technological singularity has been presented as a future event. At some point, an artificial intelligence would become as intelligent as a human being, improve itself, become superintelligent and accelerate beyond our ability to understand or control it. Humanity would stand on one side of that moment and something fundamentally different would exist on the other.

It is a dramatic story, and it may be the wrong one.

Signs, Not Directions: Compiling AI Policy into Visual Artifacts

Thu, 16 Jul 2026 18:43:53 +0100

What happens when a system stops asking an AI for the same directions repeatedly, and starts placing signs where decisions need to be made?

ZeroModel in One Image

Most AI systems repeatedly invoke a policy: observe the current state, ask a model what to do, execute the answer, and ask again at the next decision.

ZeroModel explores a different architecture. When a policy is bounded and stable, it can be compiled into a deterministic artifact that the runtime addresses directly.

What Does a Preference Know About the Future?

Fri, 10 Jul 2026 11:32:58 +0100

We Trained a Model on Editorial Choices to See Whether It Learned What Happened Next

Most preference-learning systems use a choice to change the future.

A model produces two responses. A human selects one. The chosen response becomes positive evidence, the rejected response becomes negative evidence, and training makes outputs resembling the chosen response more likely.

The preference acts as an instruction:

Produce more things like this.

I wanted to know whether the same choice could also function as evidence.

The Preference Was Only the Beginning

Tue, 07 Jul 2026 00:00:00 +0100

A preference is not only a label on what just happened. When the decision belongs to a continuing trajectory, it can also be evidence about what happens next.

Abstract

Most preference-learning systems stop at the choice.

A model produces two responses. A human selects one. The chosen response becomes positive evidence, the rejected response becomes negative evidence, and the training system moves on.

The work itself usually continues.

The selected answer may later be revised, partially retained, contradicted or abandoned. The rejected alternative may reveal a constraint that remains active long after the immediate decision. The preference is therefore not necessarily the outcome. It may be an event inside a longer trajectory.

The State Optimized the Dashboard and Lost the Citizen

Wed, 24 Jun 2026 20:19:56 +0100

An AI-assisted model of how GDP optics, housing pressure, debt rollover, and fiscal constraint can hide citizen insolvency.

1. A Country Is Its Citizens

A country is not its GDP, its bond market, its housing index, or its stock-market capitalization. A country is its citizens.

That sounds obvious enough to be useless, but most modern economic dashboards quietly forget it. They measure the state, the asset market, the tax base, the debt stock, the growth rate, the investment flow, the headline employment number, the budget balance, the bond spread, and the index level. They do not directly measure whether citizens can stand on their own.

The Moment: Intelligence beyond context

Fri, 19 Jun 2026 14:49:56 +0100

Most AI systems answer and move on. The next step is different: preserve the reasoning state, replay it, measure whether it improves, and keep only what survives verification.

Summary

Most AI workflows still treat intelligence as a single pass.

You ask a question. The model answers. Maybe you ask it to try again. Maybe you add more context. Maybe you save something to memory.

But the basic shape remains the same:

The Asset‑Price State: How the U.S. Fiscal Machine Now Depends on Rising Markets

Wed, 17 Jun 2026 17:18:52 +0100

What this post argues

The U.S. does not merely like a high stock market. It increasingly needs one.

The stock market has become an amplifier inside the largest federal revenue pipe: individual income tax. When asset prices rise, capital gains, stock compensation, options, bonuses, business equity, and other asset-sensitive income strengthen federal receipts. When the market falls hard, that same amplifier runs in reverse.

This matters because the real debt problem is not debt alone. It is interest cost relative to federal revenue. If interest grows faster than normal revenue, the system becomes more dependent on asset inflation, AI valuations, national champions, and foreign capital to keep the fiscal machine stable.

The AI Application Gap: Why Capability Is Not Deployment

Sat, 06 Jun 2026 14:40:59 +0000

Capability is real. Application is the bet

The AI economy is no longer theoretical.

AI is now showing up in financial statements, capex plans, and reported investment gains.

The largest technology companies in the world are not merely talking about AI, demoing AI, or adding AI features to their products. They are booking AI-related investment gains, redirecting capital expenditure toward AI infrastructure, reorganizing product interfaces around AI, and asking investors to value them as AI platform companies.

Warranted Search: When AI Must Prove Before It Looks

Tue, 02 Jun 2026 18:54:26 +0100

TL;DR

Modern AI systems often retrieve nearby text and generate confident answers, but that is not the same as proof. A citation can be real, the answer can be correct, and the evidence can still fail to support the claim.

This post argues for warranted search: a scoped, claim-driven form of intelligent grep. Instead of asking an AI to rummage through a corpus, we give it a specific claim, a bounded search warrant, and a limited set of safe operations.

Thinking in Primitives: Why AI Reasoning Should Learn to Point

Sun, 24 May 2026 13:16:50 +0100

From visual primitives to context-filtered reasoning, grounded verification, and AI movie repair

TL;DR

This post argues that AI reasoning should not operate over everything it can see, read, or detect. It should operate over the right primitives for the current task.

The paper Thinking with Visual Primitives shows that multimodal models reason better when they can point to visual entities using boxes and points. That solves a Reference Gap: language is often too vague to anchor reasoning to the right part of an image.

AI and the End of Easy Growth

Tue, 19 May 2026 09:52:38 +0100

Constraint, Continuity, and Human Agency

1. Introduction: The Strange Feeling Around AI

Artificial Intelligence is clearly real. The infrastructure buildout is enormous, adoption is accelerating, and AI systems are already reshaping software, research, administration, and knowledge work. Yet for many people, daily life feels strangely unchanged. Housing remains expensive, wages remain under pressure, debt continues to rise, and institutions across the West increasingly appear constrained rather than confident.

This post explores the possibility that AI is currently being deployed less as a technology of broad civilizational expansion and more as a technology of continuity management, a way for highly complex systems under demographic, economic, and energetic pressure to optimize themselves, compress costs, and maintain stability in an era where traditional growth models are becoming harder to sustain.

Delta Memory: Cargo-Culting Human Memory with Search

Mon, 18 May 2026 11:14:15 +0100

AI systems today have no idea why their own memory changes, that’s the problem we are trying to solve in this post.

Summary

Most AI memory systems start from a practical place: retrieval. Retrieval is useful, scalable, and often the right tool for the job. But if we want systems that interact with humans in more human‑like ways, we need a different analogy, not storage, but thinking.

Humans don’t store perfect records. We don’t retrieve exact text or replay video files. What we call “memory” is a shifting landscape of associations, impressions, weights, and patterns. When you recall something, you’re not pulling a file from disk, you’re running a search across your internal world, shaped by everything you’ve lived through.

Codex Manager: Building a Prompt-State Runtime for Hackathon-Grade Code Optimization

Sat, 16 May 2026 20:15:59 +0100

TL;DR

Codex Manager uses AI to generate code as an artifact, then tests that artifact, diagnoses what happened, and repairs the prompt state that produced it. The code is not the thing being optimized directly. The prompt state is.

Summary

Humanity’s Last Hackathon framed the challenge as a test of context, not code: the task was hard enough that the real question was not whether someone could hand-write one clever kernel, but whether they could build a system that used AI effectively under changing constraints.

Cognitive Graphs: A General Architecture for Replayable Reasoning

Mon, 11 May 2026 10:50:29 +0100

A Cognitive Graph is an enhanced chat log one that doesn’t just record what was said, but structurally preserves how thoughts, decisions, alternatives, and artifacts evolve over time, making the whole history replayable and auditable.

TL;DR: A Cognitive Graph turns AI-assisted work from lossy chat logs into event-sourced, replayable reasoning state. Instead of preserving only the final output, it preserves the decisions, alternatives, rationales, mutations, hashes, and snapshots that explain how the output came to exist.

AI as an Amplifier, Not a Utility

Mon, 11 May 2026 10:43:01 +0100

AI turns language into an interface for implementation.

1. The Builder’s World

There is a version of AI people talk about.

And then there is the version you discover when you actually use it consistently.

They are not the same thing.

AI’s real value is not doing old work faster.

It is this:

AI collapses the distance between an idea and a working system.

That is the part I think people are still missing.

🎂 CAKE: Cognitive Amplification Knowledge Engine

Mon, 27 Apr 2026 21:17:19 +0100

We’re not teaching machines to think. We’re teaching ourselves to build thinking systems.

🎨 From AI Assistants to Controlled Cognitive Amplification

Most people use AI to write faster.
But the real opportunity isn’t speed.

It’s amplification.

A useful analogy is physical labor. A person can move earth with their hands, but only at a limited scale. A bulldozer does not replace the human it allows them to operate at a completely different level of throughput.

The Answering Machine Effect

Mon, 27 Apr 2026 09:38:25 +0100

Why you already know what you’re about to read isn’t real and what to do about it.

Imagine a small red badge on every article, every design, every conversation: AI-Generated Content.
Before you read a single word, you feel it: a tiny click of disengagement, an instinctive pullback. You wouldn’t press “Accept cookies” without thinking, but you’d skip the AI label without even deciding.

Most people already know what they’d do. Close the tab. That reaction isn’t new. Let me take you back to the first phones.

Beyond Hallucination Energy: A Three-Dimensional Framework for Reliable AI Outputs

Wed, 22 Apr 2026 10:35:46 +0100

🧩 1. TLDR

AI doesn’t just hallucinate. Sometimes it gives answers that are fluent, safe… and completely useless.

Most discussions about AI failure focus on hallucination:

making things up
getting facts wrong
fabricating sources

That’s real. It matters.

But it’s not the most dangerous failure mode in production systems.

There is a quieter one.

A more subtle one.

And in practice a more pervasive one.

AI systems often fail not by being wrong, but by failing to think at all.

Living Against Parkinson’s: A Practical Guide to Fighting Back

Tue, 21 Apr 2026 11:52:11 +0100

🧩 SECTION 1: Introduction

How would you actually live if you were trying to fight this properly?

Not cure it. Not pretend it’s easy. But fight it intelligently, consistently, and over time.

That’s what this is.

Parkinson’s isn’t the largest disease in the world but it is one of the most demanding long-term neurological conditions a person can face. It reshapes movement, energy, thinking, and daily life and it does so unevenly, changing from day to day.

The Silent Reset: Currency Devaluation and the Extension of the Debt Cycle

Fri, 17 Apr 2026 18:44:49 +0100

Abstract

Recent analysis of U.S. fiscal dynamics suggests a structural constraint emerging around the end of this decade, driven by rising interest burdens relative to government revenue.

This paper explores the possibility that a system-level reset may already be underway, not as a discrete event, but as a gradual process of currency adjustment, inflation, and asset repricing.

A modeled 20–40% devaluation of the U.S. dollar (~30% midpoint) materially alters debt sustainability trajectories, extending the fiscal runway by an estimated 10–20 years.

The Eye That Sees

Fri, 17 Apr 2026 14:27:45 +0100

Using AI to Decode Symbols Without Assuming Meaning

Executive Summary: From Symbol to System

We set out to understand a single image. We ended up building a system that can understand structure itself.

We started with a constraint:

Assume we do not understand the symbol.

No prior knowledge. No accepted interpretations.

Just an image: an eye, a triangle, rays, an unfinished pyramid.

From that starting point, we:

Canada: When Interest Meets Reliable Revenue

Wed, 15 Apr 2026 12:55:18 +0100

Executive Summary

Canada’s fiscal position looks stable on paper. Headline interest costs consume only ~10.6% of federal revenue. But this ratio masks a structural reality: the engine that drove revenue growth has stalled, and the cost of past debt is rising faster than the system can generate new fiscal space.

For decades, population expansion concealed weak per-capita productivity. In 2025, that demographic engine stopped. At the same time, Canada does not fully capture or retain the economic value it produces, due to commodity pricing discounts, single-customer trade concentration, and high-skill outflows. When these factors are applied to the revenue base, the effective denominator shrinks.

From Fuel Protests to Fiscal Risk: What’s Really Happening in Ireland

Tue, 14 Apr 2026 17:53:37 +0100

Executive Summary

This post applies a simple, testable framework to Ireland’s fiscal system:

Fiscal constraint emerges when the cost of debt rises relative to the revenue supporting it.

In large, stable systems like the United States, this dynamic unfolds gradually. Ireland presents a different case.

While headline metrics suggest strength, three structural factors create a distinct risk profile:

Revenue composition: A significant portion derives from multinational activity and is not fully under domestic control.
Measurement distortion: The effective economic base (GNI*) is ~43% smaller than GDP implies.
Debt repricing: Existing debt is being refinanced at materially higher interest rates.

These factors introduce a critical refinement to the model:

Real Problems. AI Solutions.

Mon, 13 Apr 2026 08:53:47 +0100

How We Used AI to Analyze When U.S. Debt Becomes a Constraint

Executive Summary

We demonstrate a human + AI research process.

AI was used to:

refine the question
identify the correct metric
expose assumptions
and test the model through adversarial critique

The goal was to transform a vague macro concern into a quantifiable, testable system model.

The Question

We began with a simple but vague concern:

“Is U.S. debt becoming a problem?”

A Memory Gate for AI: Policy-Bounded Acceptance in the Executable Cognitive Kernel

Tue, 17 Mar 2026 09:58:14 +0000

Summary

Dynamic AI systems face a hidden failure mode: they can learn from their own mistakes. If every output is allowed into memory, stochastic errors do not stay local they accumulate.

In earlier posts, I argued that AI systems should not be trusted to enforce their own correctness.

Modern models are stochastic. They produce correct outputs, partially correct outputs, and completely incorrect outputs, but they do not reliably distinguish between them. That means a system that stores everything it generates will eventually learn from its own mistakes.

Intelligence Through Execution: The Executable Cognitive Kernel

Tue, 10 Mar 2026 21:58:14 +0000

🧭 Summary

Most modern AI systems treat intelligence as something stored inside a model.

A neural network is trained on massive datasets, its weights are adjusted, and those weights become the system’s knowledge. When the model produces an output, we interpret that output as the result of the intelligence encoded inside those parameters.

But this perspective has a limitation.

Once training is complete, the model is largely static. It does not improve through its own actions, and it does not adapt based on the outcome of its behavior unless we retrain it.

The “Negative Contrast Trap”: Why AI Writing Overuses “Not X, But Y”

Tue, 10 Mar 2026 12:35:56 +0000

Read enough AI prose and a rhythm starts to appear. Not fear. Not relief. Not strategy.Once you see it, you cannot unsee it.

🧠 Abstract

Large language models frequently produce rhetorical constructions such as “not fear, but relief” or “not intelligence, but memory.” While these patterns exist in human writing, AI systems tend to overproduce them, creating repetitive and unnatural prose. This article identifies the phenomenon as the Negative Contrast Trap, explains why it emerges from statistical language modeling, and proposes practical methods to detect and mitigate it in AI-assisted writing systems.

Applied Policy: How to incorporate Policy and Hallucination in self-improving system

Wed, 18 Feb 2026 08:00:16 +0000

Building a Self-Improving AI: Cooperative ERL and Embed-RL in a Trace-Native Architecture

1. The Problem

Most self-improving AI systems fail for one of three reasons:

First, scalar reward collapse. Traditional reinforcement learning compresses multi-dimensional quality into a single scalar. This creates catastrophic interference: improving one axis (e.g., coherence) can degrade another (e.g., hallucination safety). The system optimizes for the blended metric, not the underlying objectives.

Second, representation drift. Embedding-based optimization without behavioral feedback creates geometric collapse. The embedding space becomes increasingly narrow, losing discriminative power. Similar queries map to identical regions. Diversity vanishes. The system becomes brittle.

Hallucination Energy: A Geometric Foundation for Policy-Bounded AI

Thu, 05 Feb 2026 13:29:55 +0000

🚀 Summary

This post presents the current research draft and implementation of a geometric framework for bounding stochastic language models through deterministic policy enforcement.

The central contribution is a scalar metric termed Hallucination Energy, defined as the projection residual between a claim embedding and the subspace spanned by its supporting evidence embeddings. This metric operationalizes grounding as a measurable geometric quantity.

We proceed in three stages:

Formal Definition a draft manuscript introducing Hallucination Energy, its mathematical formulation, and its role within a policy-controlled architecture.
Empirical Evaluation structured calibration and adversarial stress testing across multiple domains to assess the robustness and limits of projection-based grounding.
Applied Validation large-scale evaluation on 10,000 samples from the HaluEval summarization benchmark, demonstrating that projection-based containment functions as a strong first-order grounding signal in a real generative setting.

This work does not claim to solve hallucination. Rather, it characterizes the boundary of projection-based grounding, establishes its suitability as a deterministic policy scalar, and documents both its strengths and its structural limitations.

From Evidence to Verifiability: Rebuilding Trust in AI Outputs 🔏

Tue, 03 Feb 2026 12:25:58 +0000

⏰ TLDR

This work shows that the hardest part of using AI in high-trust environments is not the model, but the policy. Once editorial policy is made explicit and executable, AI systems become interchangeable the real challenge is engineering reliable measurements and deterministic enforcement of those policies.

📋 Summary

AI systems are becoming deeply embedded in how we research, write, and reason. At the same time, their use in high-trust environments is under strain not because models are incapable, but because they are being deployed into settings that demand determinism, provenance, and enforceable rules.

Review: What We’ve Learned So Far

Mon, 01 Dec 2025 22:57:41 +0000

😶‍🌫️ Summary

This post is a quick review of the journey so far.

We’re one third of the way through the Self-Learning Systems (100-part) series, and this checkpoint pulls together the first 33 posts and the research papers that shaped them. The table below lists each post, its place in the series, and the key references it builds on, so you can see how the system and the ideas behind it have evolved since May.

✨ TINY CRITICS: Lightweight Reasoning Checks for Large AI Systems

Sat, 29 Nov 2025 00:06:42 +0000

🥹 0. TL;DR

Large language models write fluent explanations even when they’re wrong. Verifying their reasoning usually requires another LLM slow, expensive, and circular.

We needed something different:

A miniature reasoning critic <50 KB trained on synthetic reasoning mistakes, able to instantly detect broken reasoning in much larger models.

The Tiny Critic:

trains on GSM8K-style reasoning traces generated by DeepSeek or Mistral
uses FrontierLens, and Visual Policy Maps (VPMs) to convert reasoning into canonical numerical features
is just a logistic regression with ~30 parameters
runs in microseconds
plugs into any agent
dramatically improves InitAgent, R1-Loops, and research-planning stability

This post tells the full story how we built it, why it works, and what we learned about the shape of reasoning.

The Nexus Blossom: How AI Thoughts Turn into Habits

Wed, 19 Nov 2025 23:23:16 +0100

We turn any text into scorables, grow them into blossoms, and weave them into a living graph. Then we A/B test the graph’s thinking quality.

Search–Solve–Prove: building a place for thoughts to develop

Sun, 02 Nov 2025 01:13:06 +0000

🌌 Summary

What if you could see an AI think not just the final answer, but the whole stream of reasoning: every search, every dead end, every moment of insight? We’re building exactly that: a visible, measurable thought process we call the Jitter. This post the first in a series shows how we’re creating the habitat where that digital thought stream can live and grow.

We’ll draw on ideas from:

The Space Between Models Has Holes: Mapping the AI Gap

Wed, 22 Oct 2025 20:30:36 +0100

🌌 Summary

What if the most valuable insights in AI evaluation aren’t in model agreements, but in systematic disagreements?

This post reveals that the “gap” between large and small reasoning models contains structured, measurable intelligence about how different architectures reason. We demonstrate how to transform model disagreements from a problem into a solution, using the space between models to make tiny networks behave more like their heavyweight counterparts.

We start by assembling a high-quality corpus (10k–50k conversation turns), score it with a local LLM to create targets, and train both HRM and Tiny models under identical conditions. Then we run fresh documents through both models, collecting not just final scores but rich auxiliary signals (uncertainty, consistency, OOD detection, etc.) and visualize what these signals reveal.

A Complete Visual Reasoning Stack: From Conversations to Epistemic Fields

Sun, 12 Oct 2025 10:30:45 +0100

📝 Summary

We asked a blunt question: Can we see reasoning?
The answer surprised us: Yes, and you can click on it.

This post shows the complete stack that turns AI reasoning from a black box into an editable canvas. Watch as:

Your single insight becomes 10,000 reasoning variations
Abstract “understanding” becomes visible epistemic fields
Manual prompt engineering becomes automated evolution
Blind trust becomes visual verification

This isn’t just code it’s a visual way of interacting with AI, where reasoning becomes something you can see, explore, and refine.

🔦 Phōs: Visualizing How AI Learns and How to Build It Yourself

Thu, 09 Oct 2025 00:30:36 +0100

“The eye sees only what the mind is prepared to comprehend.” Henri Bergson

🔍 We Finally See Learning

For decades, we’ve measured artificial intelligence with numbers loss curves, accuracy scores, reward signals.
We’ve plotted progress, tuned hyperparameters, celebrated benchmarks.

But we’ve never actually seen learning happen.

Not really.

Sure, we’ve visualized attention maps or gradient flows but those are snapshots, proxies, not processes.

What if we could watch understanding emerge not as a number going up, but as a pattern stabilizing across time?
What if reasoning itself left a visible trace?

Episteme: Distilling Knowledge into AI

Fri, 03 Oct 2025 11:24:58 +0100

🚀 Summary

When you can measure what you are speaking about… you know something about it; but when you cannot measure it… your knowledge is of a meagre and unsatisfactory kind. Lord Kelvin

Remember that time you spent an hour with an AI, and in one perfect response, it solved a problem you’d been stuck on for weeks? Where is that answer now? Lost in a scroll of chat history, a fleeting moment of brilliance that vanished as quickly as it appeared. This post is about how to make that moment permanent, and turn it into an intelligence that amplifies everything you do.

🔄 Learning from Learning: Stephanie’s Breakthrough

Wed, 10 Sep 2025 10:09:22 +0100

📖 Summary

AI has always been about absorption: first data, then feedback. But even at its best, it hit a ceiling. What if, instead of absorbing inputs, it absorbed the act of learning itself?

In our last post, we reached a breakthrough: Stephanie isn’t just learning from data or feedback, but from the process of learning itself. That realization changed our direction from building “just another AI” to building a system that absorbs knowledge, reflects on its own improvement, and evolves from the act of learning.

From Photo Albums to Movies: Teaching AI to See Its Own Progress

Sun, 07 Sep 2025 08:50:43 +0100

🥱 TLDR

This post details the implementation of:

PACS: Implicit Actor–Critic Coupling via a Supervised Learning Framework for RLVR
NER Retriever: Zero-Shot Named Entity Retrieval with Type-Aware Embeddings within our self-improving AI, Stephanie.

The core idea is to move beyond static, single-point feedback to a richer, more dynamic form of learning:

Case Based Reasoning: Teaching AI to Learn From itself

Wed, 03 Sep 2025 23:52:29 +0100

✨ Summary

Imagine an AI that gets smarter every time it works not by retraining on massive datasets, but by learning from its own reasoning and reflection, just like humans.

Most AI systems are frozen in time. Trained once, deployed forever, they never learn from mistakes or build on successes. Real intelligence human or artificial doesn’t work that way. It learns from experience.

This is the vision behind Stephanie: a self-improving AI that gets better every time it acts, not by fine-tuning, but by remembering, reusing, and revising its reasoning.

SIS: The Visual Dashboard That Makes Stephanie's AI Understandable

Mon, 25 Aug 2025 15:30:43 +0100

🔍 The Invisible AI Problem

How do you debug a system that generates thousands of database entries, hundreds of prompts, and dozens of knowledge artifacts for a single query?

SIS is our answer a visual dashboard that transforms Stephanie’s complex internal processes into something developers can actually understand and improve.

📰 In This Post

🔎 See how Stephanie pipelines really work – from Arxiv search to cartridges, step by step.
📜 View logs and pipeline steps clearly – no more digging through raw DB entries.
📝 Generate dynamic reports from pipeline runs – structured outputs you can actually use.
🤖 Use pipelines to train the system – showing how runs feed back into learning.
🧩 Turn raw data into functional knowledge – cartridges, scores, and reasoning traces.
🔄 Move from fixed pipelines toward self-learning – what it takes to make the system teach itself.
🖥️ SIS isn’t just a pretty GUI - it’s the layer that makes Stephanie’s knowledge visible and usable.
🈸️ Configuring Stephanie – We will show you how to get up and running with Stephanie.
💡 What we learned – the big takeaway: knowledge without direction is just documentation.

❓ Why We Built SIS

When you’re developing a self-improving AI like Stephanie, the real challenge isn’t just running pipelines it’s making sense of the flood of logs, evaluations, and scores the system generates.

ZeroModel: Visual AI you can scrutinize

Mon, 11 Aug 2025 22:41:43 +0100

“The medium is the message.” Marshall McLuhan
We took him literally.

What if you could literally watch an AI think not through confusing graphs or logs, but by seeing its reasoning process, frame by frame? Right now, AI decisions are black boxes. When your medical device rejects a treatment, your security system flags a false positive, or your recommendation engine fails catastrophically you get no explanation, just a ’trust me’ from a $10M model. ZeroModel changes this forever.

Everything is a Trace: Stephanie Enters Full Reflective Mode

Sun, 03 Aug 2025 22:03:10 +0100

🔧 Summary

In our last post, Layers of Thought: Smarter Reasoning with the Hierarchical Reasoning Model, we introduced a new epistemic lens a way to evaluate not just final answers, but the entire sequence of reasoning steps that led to them. We realized we could apply this way of seeing to every action in our system not just answers, but inferences, lookups, scorings, decisions, and even model selections. This post shows how we’re doing exactly that.

Layers of thought: smarter reasoning with the Hierarchical Reasoning Model

Thu, 31 Jul 2025 09:20:54 +0100

🤝 Introduction

Forget everything you thought you knew about AI reasoning. What you’re about to discover isn’t just another scoring algorithm it’s Stephanie’s first true capacity for thought. Let’s peel back the layers of the HRM: Hierarchical Reasoning Model and see why this represents a quantum leap in how AI systems can genuinely reason rather than merely react.

Stephanie's Secret: The Dawn of Reflective AI

Sun, 27 Jul 2025 22:23:45 +0100

🌅 Introduction: The Dawn of Self-Reflective AI

What if your AI could not only answer questions but also question itself about those answers? Not with programmed doubt, but with genuine self-awareness recognizing when it’s uncertain, analyzing why it made a mistake, and systematically improving its own reasoning process? This isn’t science fiction. Today, we’re unveiling the first working implementation of an AI that doesn’t just think, but learns how to think better. It’s a bit cold here

The Shape of Thought: Exploring Embedding Strategies with Ollama, HF, and H-Net

Sat, 19 Jul 2025 22:06:13 +0100

🔍 Summary

Stephanie, a self-improving system, is built on a powerful belief:

If an AI can evaluate its own understanding, it can reshape itself.

This principle fuels every part of her design from embedding to scoring to tuning.

At the heart of this system is a layered reasoning pipeline:

MRQ offers directional, reinforcement-style feedback.
EBT provides uncertainty-aware judgments and convergence guidance.
SVM delivers fast, efficient evaluations for grounded comparisons.

These models form Stephanie’s subconscious engine the part of her mind that runs beneath explicit thought, constantly shaping her understanding. But like any subconscious, its clarity depends on how raw experience is represented.

Getting Smarter at Getting Smarter: A Practical Guide to Self-Tuning AI

Thu, 10 Jul 2025 09:01:45 +0100

🔥 Summary: The Self-Tuning Imperative

“We’re drowning in models but starved for wisdom.” Traditional AI stacks:

Require constant manual tuning
Suffer from version lock-in
Can’t explain their confidence

What if your AI system could learn which models to trust and when without your help?

In this post, we’ll show you a practical, working strategy for building self-tuning AI not theoretical, not hand-wavy, but a real system you can build today using modular components and a few powerful insights.

Epistemic Engines: Building Reflective Minds with Belief Cartridges and In-Context Learning

Wed, 02 Jul 2025 14:15:50 +0100

🔍 Summary: Building the Engine of Understanding

This is not a finished story. It’s the beginning of one and likely the most ambitious post we’ve written yet.

We’re venturing into new ground: designing epistemic engines modular, evolving AI systems that don’t just respond to prompts, but build understanding, accumulate beliefs, and refine themselves through In-Context Learning.

In this series, we’ll construct a self-contained system separate from our core framework Stephanie that runs its own pipelines, evaluates its own beliefs, and continuously improves through repeated encounters with new data. Its core memory will be made of cartridges: scored, structured markdown artifacts distilled from documents, papers, and the web. These cartridges form a kind of belief substrate that guides the system’s judgments.

Self-Improving AI: A System That Learns, Validates, and Retrains Itself

Mon, 30 Jun 2025 10:13:03 +0100

🤖 The Static AI Trap

Today’s AI systems are frozen in time: trained once, deployed forever. Yet the real world never stops evolving. Goals shift overnight. New research upends old truths. Context transforms without warning.

What if your AI could wake up?

In this post, we engineer an intelligence that teaches itself a system that continuously learns from the web, audits its own judgments, and retrains itself when confidence wavers.

Teaching Tiny Models to Think Big: Distilling Intelligence Across Devices

Fri, 27 Jun 2025 23:24:14 +0100

🧪 Summary

As AI developers, we often face the tradeoff between intelligence and accessibility. Powerful language models like Qwen3 run beautifully on servers but what about on the edge? On devices like Raspberry Pi or old Android phones, we’re limited to small models. The question we asked was simple:

Can we teach a small model to behave like a large one without retraining it from scratch using only its outputs and embeddings?

Agent Architectures: Chapter 2

Fri, 27 Jun 2025 11:24:51 +0100

This is a summary of the second chapter of a book I wrote:

Agent Architectures: Advanced Strategies for Intelligent LLM Systems

🤖 Chapter 2 : How to Think With AI Agents

Agents aren’t just tools they’re thinking partners. This post explores the core mindset shifts, methodologies, and feedback loops that define how to work with intelligent systems.

🌊 Five Core Shifts in the AI–Human Paradigm

Before diving into methods, we need to understand the big changes redefining how we work with AI:

Compiling Thought: Building a Prompt Compiler for Self-Improving AI

Thu, 26 Jun 2025 13:31:41 +0100

How to design a pipeline that turns vague goals into smart prompts

🧪 Summary

Why spend hours engineering prompts when AI can optimize its own instructions. This blog post introduces a novel approach toward creating a self-improving AI by treating prompts as programs. Traditional AI systems often rely on static instructions rigid and limited in adaptability. Here, we present a different perspective: viewing the Large Language Model (LLM) as a prompt compiler capable of dynamically transforming raw instructions into optimized prompts through iterative cycles of decomposition, evaluation, and intelligent reassembly.

Agent Architectures: Chapter 1

Thu, 26 Jun 2025 12:51:33 +0100

This is a summary of the first chapter of a book I wrote:

Agent Architectures: Advanced Strategies for Intelligent LLM Systems

🚀 Introduction to LLM Agents

🤖 What is an LLM Agent?

An LLM agent is an intelligent software system built around a large language model (LLM). Unlike traditional LLMs, these agents don’t merely respond to prompts they actively reason, maintain context, and interact dynamically with external tools and environments. This autonomy enables them to manage complex workflows independently.

Thoughts of Algorithms

Mon, 23 Jun 2025 11:10:59 +0100

How a self-evolving AI learns to reflect, score, and rewrite its own reasoning

🧪 Summary

What if an AI could think not just solve problems, but reevaluate its beliefs in the face of new information?

In this post, we introduce a system that does exactly that. At the core of our pipeline is a lightweight scoring model called MR.Q, responsible for evaluating ideas and choosing the best ones. But when it encounters a new domain, a new goal, or a shift in task format, it doesn’t freeze it adapts.

Document Intelligence: Turning Documents into Structured Knowledge

Tue, 17 Jun 2025 23:31:13 +0100

📖 Summary

Imagine drowning in a sea of research papers, each holding a fragment of the knowledge you need for your next breakthrough. How does an AI system, striving for self-improvement, navigate this information overload to find precisely what it needs? This is the core challenge our Document Intelligence pipeline addresses, transforming chaotic documents into organized, searchable knowledge.

In this post we combine insights from Paper2Poster: Towards Multimodal Poster Automation from Scientific Papers and Domain2Vec: Vectorizing Datasets to Find the Optimal Data Mixture without Training to build an AI document profiler that transforms unstructured papers into structured, searchable knowledge graphs.

Learning to Learn: A LATS-Based Framework for Self-Aware AI Pipelines

Thu, 12 Jun 2025 09:23:46 +0100

📖 Summary

In this post, we introduce the LATSAgent, an implementation of LATS: Language Agent Tree Search Unifies Reasoning.. within the stephanie framework. Unlike prior agents that followed a single reasoning chain, this agent explores multiple reasoning paths in parallel, evaluates them using multidimensional scoring, and learns symbolic refinements over time. This is our most complete integration yet of search, simulation, scoring, and symbolic tuning bringing together all of our previous work on sharpening, pipeline reflection, and symbolic rules into a unified, intelligent reasoning loop.

Dimensions of Thought: A Smarter Way to Evaluate AI

Mon, 09 Jun 2025 10:00:03 +0100

📖 Summary

This post introduces a multidimensional reward modeling pipeline built on top of the stephanieanie framework. It covers:

✅ Structured Evaluation Setup How to define custom evaluation dimensions using YAML or database-backed rubrics.
🧠 Automated Scoring with LLMs Using the ScoreEvaluator to produce structured, rationale-backed scores for each dimension.
🧮 Embedding-Based Hypothesis Indexing Efficiently embedding hypotheses and comparing them for contrastive learning using similarity.
🔄 Contrast Pair Generation Creating training pairs where one hypothesis outperforms another on a given dimension.

Programming Intelligence: Using Symbolic Rules to Steer and Evolve AI

Wed, 04 Jun 2025 20:57:20 +0100

🧪 Summary

“What if AI systems could learn how to improve themselves not just at the level of weights or prompts, but at the level of strategy itself? In this post, we show how to build such a system, powered by symbolic rules and reflection.

The paper Symbolic Agents: Symbolic Learning Enables Self-Evolving Agents introduces a framework where symbolic rules guide, evaluate, and evolve agent behavior.

Adaptive Reasoning with ARM: Teaching AI the Right Way to Think

Wed, 28 May 2025 22:22:46 +0100

Summary

Chain-of-thought is powerful, but which chain? Short explanations work for easy tasks, long reflections help on hard ones, and code sometimes beats them both. What if your model could adaptively pick the best strategy, per task, and improve as it learns?

The Adaptive Reasoning Model (ARM) is a framework for teaching language models how to choose the right reasoning format direct answers, chain-of-thoughts, or code depending on the task. It works by evaluating responses, scoring them based on rarity, conciseness, and difficulty alignment, and then updating model behavior over time.

A Novel Approach to Autonomous Research: Implementing NOVELSEEK with Modular AI Agents

Tue, 27 May 2025 22:40:50 +0100

Summary

AI research tools today are often narrow: one generates summaries, another ranks models, a third suggests ideas. But real scientific discovery isn’t a single step—it’s a pipeline. It’s iterative, structured, and full of feedback loops.

In this post, I show how to build a modular AI system that mirrors this full research lifecycle. From initial idea generation to method planning, each phase is handled by a specialized agent working in concert.

The Self-Aware Pipeline: Empowering AI to Choose Its Own Path to the Goal

Sat, 24 May 2025 13:48:15 +0100

🔧 Summary

Modern AI systems require more than just raw processing power they need contextual awareness, strategic foresight, and adaptive learning capabilities. In this post, we walk through how we implemented a self-aware pipeline system inspired by the Devil’s Advocate paper.

Unlike brittle, static workflows, this architecture empowers agents to reflect on their own steps, predict failure modes, and adapt their strategies in real time.

🧠 Grounding in Research

Devil’s Advocate (ReReST)

ReReST: Devil's Advocate: Anticipatory Reflection for LLM Agents introduces a self-training framework for LLM agents. The core idea is to have a “reflector” agent anticipate failures and revise the original plan before executing a powerful method for reducing hallucinations and improving sample quality. Our implementation draws heavily on these ideas to enable dynamic planning and feedback loops within the pipeline.

General Reasoner: The smarter Local Agent

Thu, 22 May 2025 21:41:54 +0100

🔧 Summary

The General Reasoner paper shows how we can train LLMs to reason across domains using diverse data and a generative verifier. In this post, I walk through our open-source implementation showing how we built a modular reasoning agent capable of generating multiple hypotheses, evaluating them with an LLM-based judge, and selecting the best answer.

🧠 What We Built

We built a GeneralReasonerAgent that:

Dynamically generates multiple hypotheses using different reasoning strategies (e.g., cot, debate, verify_then_answer, etc.)
Evaluates each pair of hypotheses using either a local LLM judge or our custom MR.Q evaluator
Classifies the winning hypothesis using rubric dimensions
Logs structured results to a PostgreSQL-backed system

All of this was integrated with our existing stephanie framework, which includes:

Building a Self-Improving Chain-of-Thought Agent: Local LLMs Meet the CoT Encyclopedia

Wed, 21 May 2025 18:36:51 +0100

Most AI systems generate answers. Ours examines how they think. This isn’t just prompt engineering this is structured reasoning at scale.

🔧 Summary

Large Language Models are transforming every field, yet their internal reasoning remains a formidable black box. We can get brilliant outputs, but without understanding how those conclusions were reached, we’re left guessing how to improve, debug, or even trust them. This opacity limits our ability to build truly reliable and self-improving AI systems.

Self-Improving Agents: Applying the Sharpening Framework to Local LLMs

Tue, 20 May 2025 09:23:16 +0100

This is the second post in a 100-part series, where we take breakthrough AI papers and turn them into working code building the next generation of AI, one idea at a time.

🔧 Summary

In my previous post, I introduced stephanie a modular implementation of the AI co-scientist concept, inspired by DeepMind’s recent paper Towards an AI Co-Scientist.

But now, we’re going deeper.

This isn’t just about running prompts through an agent system it’s about building something radically different:

Building an AI Co-Scientist

Thu, 15 May 2025 09:23:16 +0100

This is the first post in a 100-part series, where we take breakthrough AI papers and turn them into working code building the next generation of AI, one idea at a time.

🧾 Summary

In this post, I’ll walk through how I implemented the ideas from
AI Co-Scientist: Towards an AI Co-Scientist into a working system called Stephanie.

Building Clipper: An AI Image Generator You Control

Wed, 07 May 2025 00:00:00 +0000

“If you’ve ever pasted 50 prompts into an image generator one-by-one, this is for you. I hit my limit and built Clipper to solve it.”

📖 Summary

In the previous blog post I wrote a research paper: Cross-Modal Cognitive Mapping. This paper is about turning your conversations into images to gradually map your thought patterns. The implementation of this paper is an application called Prism.

A component of this app is image generation from prompts or your conversations. All of the Foundation models support this but it’s a pretty janky process where you have to generate the prompt paste it into a text box and download the image. I just went through a week of doing this while building a prompt toolkit. While I was doing this I kept wishing I built the app which I’m going to share with you now.

Cross-Modal Cognitive Mapping: A Technical Overview

Sat, 26 Apr 2025 00:00:00 +0000

A Technical Overview of System Design and Implementation

Author: Ernan Hughes
Published: April 2025

Abstract

Cross-Modal Cognitive Mapping is a new framework designed to extend traditional text-based cognition modeling into multimodal representations.
This system combines text prompts, visual generation, human selection behavior, and semantic memory retrieval to better understand and track human conceptual architectures.

This post presents a technical overview of the core architecture, database design, embedding workflows, search functionality, and resonance mapping built during the initial research phase.

Uncovering Reasoning in LLMs with Sparse Autoencoders

Thu, 27 Mar 2025 11:45:33 +0000

Summary

Large Language Models (LLMs) like DeepSeek-R1 show remarkable reasoning abilities, but how these abilities are internally represented has remained a mystery. This paper explores the mechanistic interpretability of reasoning in LLMs using Sparse Autoencoders (SAEs) — a tool that decomposes LLM activations into human-interpretable features. In this post, we’ll:

• Explain the SAE architecture used • Compute and visualize ReasonScore • Explore feature steering with sample completions • Provide live visualizations using Python + Streamlit

Optimizing Prompt Generation with MARS and DSPy

Mon, 24 Mar 2025 15:45:33 +0000

🕒 TL;DR

We explore MARS, a multi-agent prompt optimizer using Socratic dialogue.
We implement it using DSPy + Fin-R1 + EDGAR giving us an end-to-end financial reasoning pipeline.
We deploy the whole thing to Hugging Face Spaces with a Gradio UI.

🌟 Introduction

Prompt engineering has become the defining skill of the Large Language Model (LLM) era a delicate balance between science and art. Crafting the perfect prompt often feels like an exercise in intuition, trial, and error. But what if we could take the guesswork out of the process? What if prompts could optimize themselves?

Fin-R1: a Financial Reasoning LLM with Reinforcement Learning and CoT

Fri, 21 Mar 2025 03:27:30 +0000

Introduction

Fin-R1 is a new model specifically fine-tuned for financial reasoning, with performance that beats much larger models like DeepSeek-R1.

This post will use this model and compare it with phi3 across various tasks.

phi3 for comparison

Phi-3: a lightweight, general-purpose model known for its efficiency and strong reasoning performance at smaller parameter scales. It serves as a great baseline for assessing how domain-specific tuning in Fin-R1 improves financial understanding and response structure.

MR.Q: Model-Based Representations for Model-Free Trading

Tue, 18 Mar 2025 13:05:34 +0000

Introduction

Model-free reinforcement learning learns a policy directly from experience, but it can struggle to discover useful representations from sparse or noisy rewards. Model-based reinforcement learning receives a denser training signal by learning how states, actions, rewards, and termination relate to one another, but it often pays for that knowledge through planning complexity and model error.

MR.Q: MR.Q

Can a model-free agent keep the representation-learning benefits of a learned model without using that model to plan?

Using Hugging Face Datasets

Sat, 15 Mar 2025 13:05:34 +0000

Summary

Machine learning operates on data. Essentially, it processes data to extract meaningful information, which can then be used to make intelligent decisions. This is the foundation of Artificial Intelligence. The more data you have the better your machine learning apps will be. There is a caveat though the data has to be high quality. The more data you have and the higher quality the better your apps will be.

Detecting AI-Generated Text: Challenges and Solutions

Thu, 13 Mar 2025 13:28:24 +0000

Summary

Artificial Intelligence (AI) has revolutionized the way we generate and consume text. From chatbots crafting customer responses to AI-authored articles, artificial intelligence is reshaping how we create and consume content. As AI-generated text becomes indistinguishable from human writing, distinguishing between the two has never been more critical. Here are some of the reasons it is important to be able to verify the source of information:

Preventing plagiarism
Maintaining academic integrity
Ensuring transparency in content creation
If AI models are repeatedly trained on AI-generated text, their quality may degrade over time.

In this blog post, we’ll explore the current most effective methods for detecting AI-generated text.

Shakespeare and the Bible: An AI Investigation

Tue, 11 Mar 2025 22:47:36 +0000

Summary

Could the greatest playwright of all time have secretly shaped one of the most influential religious texts in history? Some believe William Shakespeare left his mark on the King James Bible hidden in plain sight. With the power of AI, we’ll investigate whether there’s any truth to this conspiracy.

You can read about the conspiracy here:

PostgreSQL for AI: Storing and Searching Embeddings with pgvector

Mon, 10 Mar 2025 21:35:37 +0000

Summary

Vector databases are essential for modern AI applications like semantic search, recommendation systems, and natural language processing. They allow us to store and query high-dimensional vectors efficiently. With the pgvector extension PostgreSQL becomes a powerful vector database, enabling you to combine traditional relational data with vector-based operations.

In this post, we will walk through the full process:

Installing PostgreSQL and pgvector Setting up a vector-enabled database Generating embeddings using Ollama Running similarity queries with Python By the end, you’ll be able to store, query, and compare high-dimensional vectors in PostgreSQL, opening up new possibilities for AI-powered applications.

Build Smarter AI: Leveraging the Model Context Protocol for Dynamic Context

Thu, 06 Mar 2025 13:08:42 +0000

Summary

The evolution of technology is driven by protocols structured ways for systems to communicate and interact. The internet, APIs, and even modern databases rely on protocols to function efficiently. Similarly, as AI becomes more powerful, it needs a structured and standardized way to manage context across interactions.

Enter the Model Context Protocol (MCP) a framework designed to enhance the way AI models understand, retain, and utilize context over multiple exchanges. Large Language Models (LLMs) are powerful, but without effective context management, they can:

Getting Started with Neo4j: Build Your First Knowledge Graph

Thu, 06 Mar 2025 08:37:29 +0000

Summary

In AI and data science, knowledge graphs are powerful tools for modeling complex relationships between entities. They enable intelligent querying, recommendation systems, and semantic search. Neo4j, an open-source graph database, is one of the most popular tools for building and managing knowledge graphs.

In this post, we’ll walk you through setting up Neo4j, configuring it for use as a knowledge graph, and manipulating the database using Python.

Beyond Text Generation: Coding Ollama Function Calls and Tools

Wed, 05 Mar 2025 09:07:59 +0000

Summary

Function calling allows Large Language Models (LLMs) to interact with APIs, databases, and other tools, making them more than just text generators.

Integrating LLMs with functions enables you to harness their powerful text processing capabilities, seamlessly enhancing the technological solutions you develop.

This post will explain how you can call local python functions and tools in Ollama.

Introduction to Ollama Function Calling

Ollama allows you to run state-of-the-art LLMs like Qwen, Llama, and others locally without relying on cloud APIs. Its function-calling feature enables models to execute external Python functions, making it ideal for applications like chatbots, automation tools, and data-driven systems.

From +AI to AI+: Embracing AI as the Foundation of Everything You Do

Fri, 28 Feb 2025 21:35:03 +0000

Summary

What if AI isn’t just a tool but the foundation of how you work, create, and think?

Today there are two distinct ways to approach AI: +AI and AI+. +AI means integrating AI into an existing workflow, business, or process. It’s the approach discussed in countless books, YouTube videos, and business strategies. If you’re working, running a business, or earning money, this is the natural and logical way to use AI. But this post isn’t about that. Instead this post is about AI+ a radically different approach where AI is the foundation of everything you do.

Building AI-Powered Applications with Haystack and Ollama

Fri, 28 Feb 2025 13:58:16 +0000

Summary

In this post, I will demonstrate how to set up and use haystack with Ollama.

haystack is a framework that helps when building applications powered by LLMs.

It offers extensive LLM-related functionality.
It is open source under the Apache license.
It is actively developed, with numerous contributors.
It is widely used in production by various clients.

These are some of the key items to watch for when using a library in a project.

LiteLLM: A Lightweight Wrapper for Multi-Provider LLMs

Mon, 24 Feb 2025 14:13:26 +0000

Summary

In this post I will cover LiteLLM. I used it for my implementation of Textgrad also it was using in blog posts I did about Agents.

Working with multiple LLM providers is painful. Every provider has its own API, requiring custom integration, different pricing models, and maintenance overhead. LiteLLM solves this by offering a single, unified API that allows developers to switch between OpenAI, Hugging Face, Cohere, Anthropic, and others without modifying their code.

🧠 TextGrad: Dynamic Optimization of Your LLM

Sun, 23 Feb 2025 21:47:10 +0000

🧩 Summary

This post aims to be a comprehensive tutorial on Textgrad.

Textgrad enables the optimization of LLM’s using their text responses.

This will be part of SmartAnswer the ultimate LLM query tool which I will be blogging about shortly.

❓ Why TextGrad?

🔄 Brings Gradient Descent to LLMs – Instead of numerical gradients, TextGrad leverages textual feedback to iteratively improve outputs.
🤖 Automates Prompt Optimization – Eliminates the guesswork in refining LLM prompts.
🌐 Works with Any LLM – From OpenAI’s GPT to local models like Ollama.

🧠 What is TextGrad?

⚡ Bringing Gradients to LLM Optimization

Traditional AI optimization techniques rely on numerical gradients computed via backpropagation. However in LLM-driven AI systems, inputs and outputs are often text, making standard gradient computation impossible.

The Power of Logits: Unlocking Smarter, Safer LLM Responses

Sun, 23 Feb 2025 20:51:48 +0000

Summary

In this blog post

I want to fully explore logits and how they can be used to enhance AI applications
I want to understand the ideas from this paper: “Is That Your Final Answer? Test-Time Scaling Improves Selective Question Answering”

This paper introduces a new approach, Selective Question Answering (SQA). This introduces confidence scores to decide when an answer should be given. In this post, we’ll cover the core insights of the paper and implement a basic confidence-based selection function in Python.

Efficient Similarity Search with FAISS and SQLite in Python

Sun, 23 Feb 2025 07:57:28 +0000

Summary

This is another component in SmartAnswer and enhanced LLM interface.

In this blog post, we introduce a wrapper class, FaissDB, which integrates FAISS with SQLite or any database to manage document embeddings and enable efficient similarity search. This approach combines FAISS’s vector search capabilities with the storage and querying power of a database, making it ideal for applications such as Retrieval-Augmented Generation (RAG) and recommendation systems.

It builds up this tool PaperSearch.

Automating Paper Retrieval and Processing with PaperSearch

Sat, 22 Feb 2025 07:28:15 +0000

Summary

This is part on in a series of blog post working towards SmartAnswer a comprehensive improvement to how Large Language Models LLMs answer questions.

This tool will be the source of data for SmartAnswer and allow it to find and research better data when generating answers.

I want this tool to be included in that solution but I dot want all the code from this tool distracting from the SmartAnswer solution. Hence this post.

SQLite: the small database that packs a big punch

Thu, 20 Feb 2025 07:54:29 +0000

Summary

SQLite is one of the most widely used database engines in the world, powering everything from mobile applications (Android, iOS) to browsers (Google Chrome, Mozilla Firefox), IoT devices, and even gaming consoles. Unlike traditional client-server databases (e.g., MySQL, PostgreSQL), SQLite is an embedded, serverless database that stores data in a single file, making it easy to manage and deploy.

Python developers frequently choose SQLite for its inherent simplicity and portability, leveraging the built-in sqlite3 module for effortless database integration.

RAFT: Reward rAnked FineTuning - A New Approach to Generative Model Alignment

Wed, 19 Feb 2025 14:48:58 +0000

Summary

This post is an explanation of this paper:RAFT: Reward rAnked FineTuning for Generative Foundation Model Alignment.

Generative foundation models, such as Large Language Models (LLMs) and diffusion models, have revolutionized AI by achieving human-like content generation. However, they often suffer from

Biases – Models can learn and reinforce societal biases present in the training data (e.g., gender, racial, or cultural stereotypes).
Ethical Concerns – AI-generated content can be misused for misinformation, deepfakes, or spreading harmful narratives.
Alignment Issues – The model’s behavior may not match human intent, leading to unintended or harmful outputs despite good intentions.

Traditionally, Reinforcement Learning from Human Feedback (RLHF) has been used to align these models, but RLHF comes with stability and efficiency challenges. To address these limitations, RAFT (Reward rAnked FineTuning) was introduced as a more stable and scalable alternative. RAFT fine-tunes models using a ranking-based approach to filter high-reward samples, allowing generative models to improve without complex reinforcement learning setups.

Faiss: A Fast, Efficient Similarity Search Library

Mon, 17 Feb 2025 08:16:15 +0000

Summary

Searching through massive datasets efficiently is a challenge, whether in image retrieval, recommendation systems, or semantic search. Faiss (Facebook AI Similarity Search) is a powerful open-source library developed by Meta to handle high-dimensional similarity search at scale.

It’s well-suited for tasks like:

Image search: Finding visually similar images in a large database.
Recommendation systems: Recommending items (products, movies, etc.) to users based on their preferences.
Semantic search: Finding documents or text passages that are semantically similar to a given query.
Clustering: Grouping similar vectors together.

In many of the upcoming projects in this blog I will be using it. It is a good local developer solution.

K-Means Clustering

Mon, 17 Feb 2025 06:52:23 +0000

Summary

Imagine you have a dataset of customer profiles. How can you group similar customers together to tailor marketing campaigns? This is where K-Means clustering comes into play.

K-Means is a popular unsupervised learning algorithm used for clustering data points into distinct groups based on their similarities. It is widely used in various domains such as customer segmentation, image compression, and anomaly detection.

In this blog post, we’ll cover how K-Means works and demonstrate its implementation in Python using scikit-learn.

AI: The Future Interface to Technology

Fri, 14 Feb 2025 12:58:51 +0000

Summary

Imagine a world where you simply think of a task, and invisible devices seamlessly execute it. In fact most of what used to be your daily tasks you won’t even think about they will be automatically executed. Sounds like science fiction? This I believe is the future of human technology interaction. The technology disappears behind an AI driven interface.

Do we currently have Artificial Intelligence

Artificial intelligence refers to computer programs designed to mimic human cognitive abilities, 
such as understanding natural language, recognizing patterns, learning from data, and solving complex problems.
While AGI aims to replicate general human intelligence, 
narrow AI focuses on excelling at specific tasks within predefined parameters.

A common debate in AI discourse revolves around whether large language models (LLMs) truly qualify as artificial intelligence or if they are merely sophisticated algorithms mimicking human-like behavior. While discussions about Artificial General Intelligence (AGI) a theoretical form of AI capable of replicating human cognition across all domains are intriguing, they distract from the practical applications of AI that already exist today. AGI may never materialize, not because it’s unachievable, but because it lacks practical utility. A godlike AI with unrestricted capabilities offers little tangible benefit compared to specialized narrow AI systems. Instead, what we have now is narrow AI, which excels at specific tasks and operates within defined parameters. This AI can get broader through the use of Agents and can automatically self improve and learn as I have shown in previous blog posts.

Self-Learning LLMs for Stock Forecasting: A Python Implementation with Direct Preference Optimization

Thu, 13 Feb 2025 14:22:06 +0000

Summary

Forecasting future events is a critical task in fields like finance, politics, and technology. However, improving the forecasting abilities of large language models (LLMs) often requires extensive human supervision. In this post, we explore a novel approach from the paper LLMs Can Teach Themselves to Better Predict the Future that enables LLMs to teach themselves better forecasting skills using self-play and Direct Preference Optimization (DPO). We’ll walk through a Python implementation of this method, step by step.

Using Quantization to speed up and slim down your LLM

Wed, 12 Feb 2025 11:07:50 +0000

Summary

Large Language Models (LLMs) are powerful, but their size can lead to slow inference speeds and high memory consumption, hindering real-world deployment. Quantization, a technique that reduces the precision of model weights, offers a powerful solution. This post will explore how to use quantization techniques like bitsandbytes, AutoGPTQ, and AutoRound to dramatically improve LLM inference performance.

What is Quantization?

Quantization reduces the computational and storage demands of a model by representing its weights with lower-precision data types. Lets imagine data is water and we hold that water in buckets, most of the time we don’t need massive floating point buckets to hold data that can be represented by integers. Quantization is using smaller buckets to hold the same amount of water – you save space and can move the containers more quickly. Quantization trades a tiny amount of precision for significant gains in speed and memory efficiency.

Mastering LLM Fine-Tuning: A Practical Guide with LLaMA-Factory and LoRA

Wed, 12 Feb 2025 07:07:50 +0000

Summary

Large Language Models (LLMs) offer immense potential, but realizing that potential often requires fine-tuning them on task-specific data. This guide provides a comprehensive overview of LLM fine-tuning, focusing on practical implementation with LLaMA-Factory and the powerful LoRA technique.

What is Fine-Tuning?

Fine-tuning adapts a pre-trained model to a new, specific task or dataset. It leverages the general knowledge already learned by the model from a massive dataset (source domain) and refines it with a smaller, more specialized dataset (target domain). This approach saves time, resources, and data while often achieving superior performance.

Debugging Jupyter Notebooks in VS Code

Tue, 11 Feb 2025 11:48:38 +0000

Summary

Visual Studio Code is the most popular editor for development.

Jupyter Notebooks is the most widely used way to share, demonstrate and develop code in modern AI development.

Debugging code is not just used when you have a bug. After you have written any substantial piece of code I suggest stepping through it in the debugger if possible. This can help improve you understanding and the quality of the code you have written

DeepResearch Part 3: Getting the best web data for your research

Sat, 08 Feb 2025 18:46:58 +0000

Summary

This post details building a robust web data pipeline using SmolAgents. We’ll create tools to retrieve content from various web endpoints, convert it to a consistent format (Markdown), store it efficiently, and then evaluate its relevance and quality using Large Language Models (LLMs). This pipeline is crucial for building a knowledge base for LLM applications.

Web Data Convertor (`MarkdownConverter`)

We leverage the MarkdownConverter class, inspired by the one in autogen, to handle the diverse formats encountered on the web. This ensures consistency for downstream processing.

DeepResearch Part 2: Building a RAG Tool for arXiv PDFs

Fri, 07 Feb 2025 19:33:51 +0000

Summary

In this post, we’ll build a Retrieval Augmented Generation (RAG) tool to process the PDF files downloaded from arXiv in the previous post DeepResearch Part 1. This RAG tool will be capable of loading, processing, and semantically searching the document content. It’s a versatile tool applicable to various text sources, including web pages.

Building the RAG Tool

Following up on our arXiv downloader, we now need a tool to process the downloaded PDF’s. This post details the creation of such a tool.

DeepResearch Part 1: Building an arXiv Search Tool with SmolAgents

Fri, 07 Feb 2025 08:33:23 +0000

Summary

This post kicks off a series of three where we’ll build, extend, and use the open-source DeepResearch application inspired by the Hugging Face blog post. In this first part, we’ll focus on creating an arXiv search tool that can be used with SmolAgents.

DeepResearch aims to empower research by providing tools that automate and streamline the process of discovering and managing academic papers. This series will demonstrate how to build such tools, starting with a powerful arXiv search tool.

FFmpeg: A Practical Guide to Essential Command-Line Options

Thu, 06 Feb 2025 13:38:55 +0000

Introduction

FFmpeg is an incredibly versatile command-line tool for manipulating audio and video files. This post provides a practical collection of useful FFmpeg commands for common tasks.

FFmpeg Command Structure

The general structure of an FFmpeg command is:

ffmpeg [global_options] {[input_file_options] -i input_url} ... {[output_file_options] output_url} ...

Merging Video and Audio

Merging video and audio, with audio re-encoding

ffmpeg -i video.mp4 -i audio.wav -c:v copy -c:a aac output.mp4

Copying the audio without re-encoding

ffmpeg -i video.mp4 -i audio.wav -c copy output.mkv

Why copy audio?

Writing Neural Networks with PyTorch

Thu, 06 Feb 2025 08:44:07 +0000

Summary

This post provides a practical guide to building common neural network architectures using PyTorch. We’ll explore feedforward networks, convolutional neural networks (CNNs), recurrent neural networks (RNNs), LSTMs, transformers, autoencoders, and GANs, along with code examples and explanations.

1️⃣ Understanding PyTorch’s Neural Network Module

PyTorch provides the torch.nn module to build neural networks. It provides classes for defining layers, activation functions, and loss functions, making it easy to create and manage complex network architectures in a structured way.

Mastering Prompt Engineering: A Practical Guide

Wed, 05 Feb 2025 14:58:04 +0000

Summary

This post provides a comprehensive guide to prompt engineering, the art of crafting effective inputs for Large Language Models (LLMs). Mastering prompt engineering is crucial for maximizing the potential of LLMs and achieving desired results.

Effective prompting is the easiest way to enhance your experience with Large Language Models (LLMs).

The prompts we make are our interface to LLMs. This is how we communicate with them. This is why it is important to understand how to do it well.

Harnessing the Power of Stable Diffusion WebUI

Wed, 05 Feb 2025 12:39:16 +0000

Summary

In this blog I aim to try building using open source tools where possible. The benefits are price, control, knowledge and eventually quality. In the shorter term though the quality will trail the paid versions. My belief is we can construct AI applications to be self correcting sort of like how your camera auto focuses for you. This process will involve a lot of computation so using a paid service could be costly. This for me is the key reason to choose solutions using free tools.

Creating AI-Powered Paper Videos: From Research to YouTube

Fri, 31 Jan 2025 11:09:13 +0000

Summary

This post demonstrates how to automatically transform a scientific paper (or any text/audio content) into a YouTube video using AI. We’ll leverage several powerful tools, including large language models (LLMs), Whisper for transcription, Stable Diffusion for image generation, and FFmpeg for video assembly. This process can streamline content creation and make research more accessible.

Overview

Our pipeline involves these steps:

Audio Generation (Optional): If starting from a text document, we’ll use a text-to-speech service (like NotebookLM, or others) to create an audio narration.
Transcription: We’ll use Whisper to transcribe the audio into text, including timestamps for each segment.
Database Storage: The transcribed text, timestamps, and metadata will be stored in an SQLite database for easy management.
Text Chunking: We’ll divide the transcript into logical chunks (e.g., by sentence or time duration).
Concept Summarization: An LLM will summarize the core concept of each chunk.
Image Prompt Generation: Another LLM will create a detailed image prompt based on the summary.
Image Generation: Stable Diffusion (or a similar tool) will generate images from the prompts.
Video Assembly: FFmpeg will combine the images and audio into a final video.

Prerequisites

Hugging Face CLI: Install it to download the Whisper model: pip install huggingface_hub
Whisper: Install the whisper-timestamped package, or your preferred Whisper implementation.
Ollama: You’ll need a running instance of Ollama to access the LLMs.
Stable Diffusion WebUI (or similar): For image generation.
FFmpeg: For video and audio processing. Ensure it’s in your system’s PATH.
Python Libraries: Install necessary Python packages: pip install pydub sqlite3 requests Pillow (and any others as needed).

1️⃣ Audio Generation (Optional)

If you’re starting with a text document, you’ll need to convert it to audio. Several cloud services and libraries can do this. For this example, we’ll assume you have an audio file (audio.wav).

Fast Poisson Disk Sampling in Arbitrary Dimensions

Tue, 28 Jan 2025 15:01:00 +0000

Summary

In this post I explore Robert Bridson’s paper: Fast Poisson Disk Sampling in Arbitrary Dimensions and provide an example python implementation. Additionally, I introduce an alternative method using Cellular Automata to generate Poisson disk distributions.

Poisson disk sampling is a widely used technique in computer graphics, particularly for applications like rendering, texture generation, and particle simulation. Its appeal lies in producing sample distributions with “blue noise” characteristics—random yet evenly spaced, avoiding clustering.

Activation Functions

Tue, 28 Jan 2025 09:16:10 +0000

Introduction

Activation functions are a component of neural networks they introduce non-linearity into the model, enabling it to learn complex patterns. Without activation functions, a neural network would essentially act as a linear model, regardless of its depth.

Key Properties of Activation Functions

Non-linearity: Enables the model to learn complex relationships.
Differentiability: Allows backpropagation to optimize weights.
Range: Defines the output range, impacting gradient flow.

In this post I will outline each of the most common activation functions how they are calculated and when they should be used.

SVM Support Vector Machine an introduction

Mon, 27 Jan 2025 14:41:41 +0000

Summary

In this post I will implement a Support Vector Machine (SVM) in python. Then describe what it does how it does it and some applications of the instrument.

What Are Support Vector Machines (SVM)?

Support Vector Machines (SVM) are supervised learning algorithms used for classification and regression tasks. Their strength lies in handling both linear and non-linear problems effectively. By finding the optimal hyperplane that separates classes, SVMs maximize the margin between data points of different classes, making them highly effective in high-dimensional spaces.

Color wars: Cellular Automata fight until one dominates

Tue, 21 Jan 2025 11:53:56 +0000

Summary

This post is about color wars: a grid containing dynamic automata at war until one dominates.

Implementation

The implementation consists of two core components: the Grid and the CellularAutomaton.

1️⃣ CellularAutomaton Class

The CellularAutomaton class represents individual entities in the grid. Each automaton has:

Attributes: ID, strength, age, position.
Behavior: Updates itself by aging, reproducing, or dying based on simple rules.

2️⃣ Grid Class

The Grid manages a collection of automata. It:

Cellular Automata: Traffic Flow Simulation using the Nagel-Schreckenberg Model

Sat, 18 Jan 2025 16:38:07 +0000

Summary

The Nagel-Schreckenberg (NaSch) model is a traffic flow model which uses used cellular automata to simulate and predict traffic on roads.

Design of the Nagel-Schreckenberg Model

Discrete Space and Time:
- The road is divided into cells, each representing a fixed length (e.g., a few meters).
- Time advances in discrete steps.
Vehicle Representation:
- Each cell is either empty or occupied by a single vehicle.
- Each vehicle has a velocity (an integer) which determines how many cells it moves in a single time step.

Rules of the Model:

The NaSch model uses local rules to update the state of each vehicle at every time step. These rules are:

Acceleration:

Simulate Gastropod Shell Growth Using Cellular Automata

Sat, 18 Jan 2025 03:03:36 +0000

Summary

I started with this paper A developmentally descriptive method forquantifying shape in gastropod shells and bridged the results to a cellular automata approach.

An example of the shell we are modelling:

Steps

1️⃣ Identify the Key Biological Features

The paper outlines the logarithmic helicospiral model for shell growth, where:

The shell grows outward and upward in a spiral shape.
Parameters like width growth ($g_w$), height growth ($g_h$), and aperture shape dictate the final form.

These features describe how the shell expands over time in a predictable geometric pattern.

Cellular Automata: Introduction

Thu, 16 Jan 2025 00:21:05 +0000

Summary

This page is the first in a series of posts about Cellular Automata.

I believe that we could get the first evidence of AI through cellular automata.

A recent paper Intelligence at the Edge of Chaos found that LLM’s trained on more complex data generate better results. Which makes sense in a human context like the harder the material is I study the smarter I get. We need to find out why this is also the case with machines. The conjecture of this paper is that creating intelligence may require only exposure to complexity.

Rag: Retrieval-Augmented Generation

Tue, 14 Jan 2025 14:40:59 +0000

Summary

Retrieval-Augmented Generation (RAG) is a powerful technique that enhances large language models (LLMs) by allowing them to use external knowledge sources.

An Artificial Intelligence (AI) system consists of components working together to apply knowledge learned from data. Some common components of those systems are:

Large Language Model (LLM): Typically the core component of the system, often there is more than one. These are large models that have been trained on massive amounts of data and can make intelligent predictions based on their training.

CAG: Cache-Augmented Generation

Fri, 10 Jan 2025 20:32:03 +0000

Summary

Retrieval-Augmented Generation (RAG) has become the dominant approach for integrating external knowledge into LLMs, helping models access information beyond their training data. However, RAG comes with limitations, such as retrieval latency, document selection errors, and system complexity. Cache-Augmented Generation (CAG) presents an alternative that improves performance but does not fully address the core challenge of small context windows.

RAG has some drawbacks - There can be significant retrieval latency as it searches for and organizes the correct data.
- There can be errors in the documents/data it selects as results for a query. For example it may select the wrong document or give priority to the wrong document. - It may introduce security and data issues 2️⃣.
- It introduces complication
- an external application to manage the data (Vector Database) - a process to continually update this data when the data goes stale

Agents: A tutorial on building agents in python

Tue, 07 Jan 2025 16:51:43 +0000

LLM Agents

Agents are used enhance and extend the functionality of LLM’s.

In this tutorial, we’ll explore what LLM agents are, how they work, and how to implement them in Python.

What Are LLM Agents?

An agent is an autonomous process that may use the LLM and other tools multiple times to achieve a goal. The LLM output often controls the workflow of the agent(s).

What is the difference between Agents and LLMs or AI?

Agents are processes that may use LLM’s and other agents to achieve a task. Agents act as orchestrators or facilitators, combining various tools and logic, whereas LLMs are the underlying generative engines.

Courses: Free course on Agentic AI

Tue, 07 Jan 2025 16:11:41 +0000

Agents were important in Machine Learning development last year.

These are some courses I have done and recommend they are all free.
A good reason to do courses and look at youtube videos is you will learn current applications of AI and may get ideas for new applications.

AI Agentic Design Patterns with AutoGen

Topics: Agents, Microsoft, Autogen.

Ollama: The local LLM solution

Mon, 06 Jan 2025 19:52:16 +0000

Using Ollama

Introduction

Ollama is the best platform for running, managing, and interacting with Large Language Models (LLM) models locally. For Python programmers, Ollama offers seamless integration and robust features for querying, manipulating, and deploying LLMs. In this post I will explore how Python developers can leverage Ollama for powerful and efficient AI-based workflows.

1️⃣ What is Ollama?

Ollama is a tool designed to enable local hosting and interaction with LLMs. Unlike cloud-based APIs, Ollama prioritizes privacy and speed by running models directly on your machine. Key benefits include:

Hugo: A Static Site Generator

Mon, 06 Jan 2025 17:34:21 +0000

Hugo: A Static Site Generator

In this post I give an introduction to what I think is the best static site generator: Hugo.

What is Hugo?

Hugo is an open-source static site generator written in Go. It takes structured content, often written in Markdown, and compiles it into static HTML, CSS, and JavaScript files.

Setting Up Hugo: A Quickstart Guide

Follow these steps to set up your first Hugo site

**1️⃣ Install Hugo

First, ensure you have Hugo installed. Use your package manager of choice:

ChromaDB: The Lightweight Open-Source Vector Database for AI Applications

Wed, 06 Mar 2024 14:08:42 +0000

1️⃣ Introduction

In the era of AI-powered search, retrieval-augmented generation (RAG), and recommendation systems, efficient vector search is a necessity. While many vector databases exist, most require heavy infrastructure.

Enter ChromaDB: a lightweight, open-source vector database optimized for rapid prototyping and local AI applications.

2️⃣ What is ChromaDB?

Definition:

ChromaDB is a vector database for storing and querying embeddings. It provides an easy-to-use interface for AI developers to integrate similarity search into their applications.

Project 8: acdb a super fast database for Android

Thu, 19 May 2016 23:45:48 +0100

An android implementation of [CDB] (https://cr.yp.to/cdb.html) database. With some simple testing I am seeing a five to ten times increase in speed over Sqlite

Project 7: FX-Trader

Thu, 12 May 2016 23:45:48 +0100

A derivatives trading system. This is my attempt at building a derivatives trading system. In this first post I am going to outline the goals of the project and some of the early design decisions.

Project 6: Validator

Thu, 28 Apr 2016 23:45:48 +0100

A validation tool for excel files. Sometimes you need to export data from one system for loading into another. For instance you may export a report from a derivatives trading system for information for a collateral management system.

This Excel macro file validates input files to make sure that they are in a specific format. The input file can be in any format that excel can load. The workbook will load the file and check for errors in place.

Project 5: Dictator

Mon, 28 Mar 2016 23:45:48 +0100

Google have just released their speech API. One really cool feature is the ability to transcribe voice in real time. Two years ago I built an app with this idea in mind. At that at the time I could no make it work. Now it is time to resurrect that app. This post will cover the recording section of that application.

Project 4: Meth

Tue, 08 Mar 2016 20:46:38 +0000

This is another simple android application. It does one thing It keeps your phone awake.

Project 3: Site Shot

Wed, 03 Feb 2016 20:46:38 +0000

This is a really simple android application. It does one thing It takes a photo of a web site and allows you to share the photo.

A script to generate android images

Wed, 03 Feb 2016 20:27:15 +0000

This is a script I use in my android projects to generate different sized images.

You can find the script here process.vbs

So I build all my images in inkscape.

This is brilliant application.

You can find some brilliant tutorials here heathenx

The script uses inkscape to convert the svg files to png images of different sizes.

The script also use imagemajic to format the pngs nicely.

Finally it compresses the result using two png crushing programs

A simple android log class

Mon, 01 Feb 2016 23:00:08 +0000

This is a very simple log class I reuse in my projects

It is a hybrid of Timber by Jake Wharton and the Log in Android Universal Image Loader by Sergey Tarasevich

Everything

Sun, 31 Jan 2016 14:39:14 +0000

I think that this tool is the best search tool for windows.

Everything

An android SharedPreferences wrapper class

Sun, 31 Jan 2016 00:08:26 +0000

This is a wrapper around the Android SharedPreferences

It adds a few useful extensions

Tools I use for this Blog

Sat, 30 Jan 2016 19:19:19 +0000

In this post I am going to share some of the tools I currently use to build the blog.

Project 2: File Explorer for android

Sat, 30 Jan 2016 00:13:56 +0000

In this project I am building a file explorer library for android. As I was working on catcher it became obvious I would need a file picker and explorer solution. So I did a bit of looking on the web. I found three interesting projects that nearly did what I wanted. I put a few of them together to come up with a hybrid solution.

Project 1: Catcher

Mon, 25 Jan 2016 22:06:44 +0000

This is an android application to transfer files from your phone to somewhere else. I will be built as a PC solution but can be used for a server solution also.

Mon, 01 Jan 0001 00:00:00 +0000

Chapter 1: Introduction to LLM Agents

What is an LLM Agent

An LLM agent is a software system built around a large language model (LLM) that can autonomously perform tasks by combining language generation with reasoning, memory, and external tools. Unlike traditional LLMs that simply respond to prompts, LLM agents maintain context, plan their actions, and interact dynamically with their environment. This allows them to handle more complex tasks and workflows independently.

Mon, 01 Jan 0001 00:00:00 +0000

AI Is the Interface: The Future of Human-Technology Interaction

Technology is the bridge that transforms data into knowledge.

In the coming years, artificial intelligence will evolve from being a tool that assists humans to becoming the primary interface through which we interact with technology and process information. The future of human-computer interaction will not be through keyboards, touchscreens, or even direct programming—it will be mediated by AI systems that understand, interpret, and execute our intentions seamlessly.

Mon, 01 Jan 0001 00:00:00 +0000

🧠 SECTION 14: The Council of You

There are moments where you don’t need data.

You need to talk.

To think something through. To vent. To get perspective when your own thoughts feel stuck or circular.

But Parkinson’s complicates that.

Because:

mood fluctuates
energy fluctuates
clarity fluctuates

Which means:

the version of you doing the thinking is not always the most reliable one

The idea

So instead of relying on a single voice—your current state—