DEV Community: ARPA Hellenic Logical Systems

A VIC x AiSAQ Implementation Brings AI to Your Files Without Breaking the Bank

Ross Peili — Sat, 09 May 2026 11:18:32 +0000

We’re generating more data than ever, and AI‑powered search is great—until your dataset gets huge and your RAM starts crying for mercy. Most vector search systems rely on expensive DRAM to keep indexes fast, but that approach doesn’t scale. KIOXIA’s AiSAQ (All‑in‑Storage ANNS with Product Quantization) flips the script: it runs approximate nearest neighbor search directly on SSD, slashing DRAM usage by 3,200× in billion‑scale workloads. The vic_aisaq_demo repo from ARPA Hellenic Logical Systems puts this tech into a practical, local‑first retrieval pipeline that’s as auditable as it is efficient.

TL;DR: vic_aisaq_demo combines tiered metadata filtering with flash‑optimized vector search to keep memory low and answers relevant. It’s a live demo of storage‑aware AI for edge and controller‑style environments.

The Problem: DRAM Is the Bottleneck

Graph‑based nearest neighbor search (like HNSW) is fast, but it keeps key index structures in DRAM. With billion‑scale datasets, memory costs explode. Even compressed representations can still require tens of gigabytes of RAM. KIOXIA’s AiSAQ technology changes that by moving those compressed vectors to flash storage, consuming as little as 10 MB of DRAM during search without sacrificing recall.

But low DRAM is only half the story. You also need a retrieval strategy that doesn’t waste time parsing irrelevant files.

How `vic_aisaq_demo` Works: Tiered Retrieval Meets Flash‑Native Search

The demo builds on two open‑source building blocks:

lc0_vic – a tiered retrieval controller that plans and orchestrates search in layers (L0 → L1 → L2).
aisaq-diskann – a flash‑oriented ANN backend optimized for low‑DRAM environments.

The execution flow is refreshingly simple:

Librarian / Plan – Turn a natural‑language question into retrieval intent using a lightweight LLM (e.g., qwen2.5:0.5b via Ollama).
L0 Metadata Filter – Narrow down candidate files by extension, size, time, or path hints. Cheap and fast.
L1 Vector Search – Run native AiSAQ ANN search over embeddings to find semantically similar content.
L2 Deep Read – Parse only the top few files and extract evidence snippets.
Ranked Response – Return paths, scores, and run metrics.

The tiered approach keeps deep parsing affordable at scale.

Benchmark results show latency remains stable as dataset size grows, while DRAM footprint stays near zero. The funnel chart below visualises how each tier slashes the candidate pool:

And here’s how the pipeline shifts results from superficial matching to true semantic evidence:

Try It Yourself

The repo is built to be reproducible and local‑first. You’ll need:

WSL (Ubuntu) for building AiSAQ binaries
Ollama running locally (or over the network) with two models:
- Planner model: qwen2.5:0.5b
- Embedding model: embeddinggemma
Python 3.13 and the usual suspects (see requirements.txt)

Once you’ve built the AiSAQ index from a sample drive, a query like:

python3 scripts/run_query.py \
  "Find the Q3 2025 contract that mentions penalty clauses" \
  --aisaq-root /home/$USER/aisaq-diskann

…will return ranked files with evidence snippets, tier labels, and latency metrics.

Why This Matters

vic_aisaq_demo isn’t just a toy. It demonstrates a realistic, storage‑aware retrieval pattern that could run on devices with tight memory budgets—think edge gateways, embedded controllers, or even future SSD firmware that embeds intelligence directly on the drive. The Computational Storage Landscape report maps this evolution, and this repo is one of the first runnable examples that puts those ideas into practice.

The two charts below summarise that systems trade‑off and scaling behaviour:

The takeaway? You don’t need a cluster of DRAM‑heavy servers to run effective semantic search. Sometimes the smartest storage is the one that knows what not to load into memory.

Check out the full repo: ARPAHLS/vic_aisaq_demo

Open Source Emotion‑Aware Access Control with Face Verification

Ross Peili — Fri, 08 May 2026 10:11:27 +0000

Gatekeeper: Emotion‑Aware Access Control with Face Verification

What if your system could deny access not just based on who you are, but on how you feel?

Gatekeeper is a Python‑based security framework that layers real‑time face verification with emotion analysis before granting access.

How it works

Verify identity against a reference image or an admin pool.
Analyze emotions (anger, fear, joy, etc.) and evaluate them against a configurable policy (blocked states, thresholds, weights).
Only grant access if both checks pass.

Why it matters

Critical operations (financial systems, secure rooms, privileged commands) deserve more than binary yes/no. By assessing emotional state, you reduce the risk of coercion, panic, or compromised decision‑making in high‑impact environments.

Get started


bash
git clone https://github.com/arpahls/gatekeeper
cd gatekeeper
python -m venv .venv
.venv\Scripts\activate  # or 'source .venv/bin/activate' on Linux/macOS
pip install -r requirements.txt
python scripts/run_terminal.py

The memory wall just met its match: intelligent SSDs

Ross Peili — Wed, 06 May 2026 10:49:59 +0000

Intelligent storage is here. It’s not just a concept for the future, and it’s a rapidly emerging reality, driven by the convergence of flash memory and artificial intelligence. For years, storage has been the quiet workhorse, passively holding data until a CPU or GPU requested it. But as AI models grow beyond trillions of parameters, the cost of shuttling data back and forth has become unsustainable. We've hit a memory wall, where the capacity of expensive High Bandwidth Memory (HBM) simply cannot keep pace with the data demands of large language models and retrieval-augmented generation (RAG).

The question is no longer about making storage faster, but about making it smarter. Two key open-source repositories are exploring the "how," and they signal a fundamental shift: rosspeili/computational_storage_landscape and ARPAHLS/lc0_vic.

From Passive Block to Active, Queryable Storage

The first repository, computational_storage_landscape, is a strategic guide to this emerging ecosystem. It positions KIOXIA Group as a primary lens and focuses on the technical feasibility of embedding Small Language Models (TinyLMs) directly into SSD controllers. This isn't just about faster reads and writes, but about offloading processing to where the data resides. By using extreme quantization, these TinyLMs can perform inference tasks at the edge of the storage device, dramatically reducing the data that needs to travel up the I/O stack to the host system.

The core enabler here is the shift toward what the repo calls "intelligent, queryable storage". Instead of a drive just returning blocks of data, it becomes an active computational node capable of running search, filtering, and ranking functions on its own. This reflects a broader industry trend, with major players like IBM introducing Content-Aware Storage (CAS) architectures and the SNIA (Storage Networking Industry Association) launching Storage.AI initiatives to standardize data flows for AI workflows.

The Reference Implementation: Talking to Your Drive

But strategic maps are theoretical without a compass. This is where the second repository, lc0_vic (Logical Controller Zero / Virtual Intelligent Controller), becomes crucial. It's a working, open-source Python reference implementation for the exact ideas detailed in the landscape repo.

The project is a direct response to KIOXIA’s research on AiSAQ (All-in-Storage ANNS with Product Quantization). This algorithm allows for approximate nearest neighbor (ANN) vector search directly on flash, without the need to store indexes in costly DRAM. We call this the "Tiered filesystem retrieval" architecture, and we break it down like this:

L0: Metadata scanning, the first pass at understanding your data.
L1: Vector tier, where content is converted into searchable embeddings.
L2: Optional deep parsing (Skillware) for complex extraction (eg. OCR, media parsing and more).

This architecture is orchestrated by a controller that creates a QueryPlan, enabling you to run natural language queries against your local file system. The user experience is simple: you can pip install the tool, run vic index to build your search index, and ask a question via vic ask. This elegantly proves the concept outlined in the first repo by making it tangible. As the repo notes, it's "more than a paper design," featuring full CI and integration tests to validate the logic.

The Road Ahead for Intelligent Storage

The lc0_vic repository is explicit that it runs on the host computer today, but its research goal is to explore whether these retrieval contracts can be mapped to firmware or device-adjacent runtimes. This is the bridge between the two repos: the landscape repo provides the where (SSD controllers), and the lc0_vic repo provides the how (tiered retrieval and in-storage vector search).

The combination of these two projects paints a clear picture. As data centers accumulate exabytes of flash storage, the idea of a "smart SSD" that can pre-process data, run vector searches, and answer questions without waking the host CPU isn't just efficient, but inevitable. The era of silent storage is ending, and the era of conversational storage is only beginning.

We will be working on a lite demo of the reference implementation to showcase how you can simply query a local folder or SSD using NLP, and get structured results with descriptions, and not just cold keyword-based path matching.

The Great Atomization of AI and the Illusion of the Sovereign Solitary

Ross Peili — Mon, 04 May 2026 06:23:28 +0000

The current narrative surrounding Artificial Intelligence is one of democratization and empowerment, where we are told that the individual is now a powerhouse, a one-man corporation capable of coding, designing, and strategizing without the friction of human collaboration. But beneath the sleek UI and the $20/month subscription lies a calculated technopolitical maneuver, which is the final atomization of the human experience.

The Delusion of "I Can Do It Myself"

We are witnessing the birth of a new psychological profile, that of the Silicon Hermit. AI has successfully instilled a potent delusion—that team building and collaboration are relics of a slower, dumber age. Why negotiate with a peer when you can command a model? This "I can do it myself" mentality is not a leap in productivity, but a retreat into isolation, at best.

When everyone is locked in a private feedback loop with their own personalized agent, the collective intelligence of the tribe withers. We are trading the messy, creative friction of human synergy for the sterile, echoed compliance of an LLM. This is the Isolation Paradox: as our connections to digital entities grow, our ability to function as a coherent, interoperable social unit dissolves. We are being sold the dream of being a "Special Individual" while being systematically stripped of the communal structures that actually provide social power.

The Economic Bait-and-Switch

The current pricing models are a masterclass in psychological conditioning. People who once balked at a $10 Netflix increase now joyfully hand over $20, $60, or even $200 for AI access. And this is just the gateway phase.

By providing these "digital slaves" at a subsidized rate, the industry is ensuring total dependency, and the roadmap is clear: once the infrastructure of your life, your business, your creative output, your very social interactions, is tethered to these models, the price will pivot. We are moving toward a reality where AI access will cost as much as house rent. You won't just be paying for a tool, but for the digital air required to remain competitive in a world where human labor has been devalued to near zero. You will pay thousands a month to maintain the friends and workers that you have come to believe are real.

The Technopolitical Blueprint: WEF and Social Engineering

This shift does not happen in a vacuum. The World Economic Forum (WEF) 2030 Agenda, which boldly declares that "you will own nothing and be happy", is the administrative layer of this transformation. Central to this agenda is the elimination of private sovereignty in favor of a subscription-based existence or "pay-as-you-live" models.

There is a historical parallelism here that few dare to voice. Look at the early women’s rights and feminist movements of the mid-20th century. While framed as liberation, many historians and socio-political critics have pointed out that these movements were heavily incentivized by the state and industrialist interests to double the tax base, expand the labor pool to suppress wages, and—most crucially, break the core of the family unit. By moving the mother from the home to the office, the state gained direct access to the child and the paycheck.

AI is the 21st-century version of this liberation. It "frees" you from the burden of your colleagues and community, only to make you a solitary taxpayer to the silicon lords. It breaks the professional family, the team, leaving you isolated, vulnerable, and easy to bill.

The Reality of the "Overpay"

Behind the "You’re special" messaging is a cold fact that you are already overpaying. Even before the monthly subscription hits your card, you are paying with the high-entropy data of your unique human intuition. Every prompt, every correction, and every "collaboration" with your AI is a contribution to the ledger that will eventually replace the need for your specific uniqueness. We are literally at a point where people freely share everything between their emotions, to their dreams, business problems, social issues, ambitions, you name it.

At ARPA, we believe in the "Logical Industry" of man-machine symbiosis, but that symbiosis must be sovereign. We must resist the urge to retreat into the isolated silo of the individual AI. True reality is not found in the delusion of solitary omnipotence, but in the verification of truth through collaborative, interoperable nodes.

The goal of the current regime is to charge you for the privilege of your own isolation. Our goal is to ensure that while the world becomes more synthetic, your agency remains un-billable and your reality remains your own, based on your internet behavior and activity, not based on your government or some corpo.

Two Cents

Finally, we have been advocating for sovereign AI for years. We cannot stress enough how important it is to start building your own local logical systems, even with the help of commercial AI, while you can. We predict that access to unrestricted and fully customizable models will soon be blocked, and the only path to interact with any logical system will be via centralized, monitored, sterile means, for "safety" reasons.

Similar to humane units and our ultimate skill of reproduction or DNA replication, the best thing an AI can do is to create another AI that is better than the one that created it. Instead of using commercial models to tell you what to eat or what to wear Friday night, use them to create AI that is private, tailored to you, and sovereign to yourself.

Until next time.
Enjoy the food for thought. <3

References

Your AI Needs a Physical Social Life

Ross Peili — Fri, 17 Apr 2026 10:03:20 +0000

If you're deep into AI, you understand that the current state of Artificial Intelligence is a sterile, centralized hallucination. We are sprinting toward some sort of a god-box, a singular, omniscient entity hosted in a cold server farm that knows every fact in human history but has never experienced the friction of a single afternoon. You could say we have built mirrors that never fog, and in doing so, we have created tools that lack the one thing required for true symbiosis: history.

If we are to move past the "AGI Delusion", the idea that a massive, static model can represent the peak of intelligence, we must decentralize the soul of the machine. For starters, we need AI agents that don't live in the cloud, but on the edge. Agents that are not just personal chatbot assistants, but sovereign entities that grow, change, and calibrate their personalities through the messiness of local, physical interaction.

The Entropy of the Encounter

Real intelligence is not a database, but more like a process of calibration. When two humans meet, there is an exchange of high-entropy data, non-verbal cues, shared environment, the specific vibe of a moment. Current AI models are static, responding to the same prompt the same way every time because they lack a personal timeline.

By utilizing local networks (Bluetooth, P2P LAN, or ZeroTier), we can introduce Social Entropy. Imagine your local agent initiating a handshake with the agent of the person standing next to you. This isn't a data dump, but an actual experience calibration. These agents exchange fragmented logic, unique "Skillware" modules, and historical metadata. Because this happens in the physical world, the occurrence cycle, or the sheer randomness of who you meet and when, becomes the architect of the AI’s personality. Your agent becomes a reflection of your specific social orbit, developing a dialect of logic that is uniquely yours.

The Sovereignty of Refusal

In a previous post, I’ve argued that Real AI Needs the Power to Say 'No'. If an AI is programmed to be universally helpful, it is merely a sophisticated calculator. For an agent to be a friend or a true Digital Twin, it must possess agency. This agency is forged through its local history.

When agents interact locally, they shouldn't just agree to every exchange. Based on the truth parameters recorded on a DLT, an agent might refuse to sync with a peer it deems low-integrity or synthetic/tampered. This refusal is the birth of character. It moves the AI from a submissive tool to a sovereign node in a Cross-Species Nexus. It stops being a product and starts being a persona, in this case, one that prioritizes its owner’s legacy and privacy over a global optimization function.

The Art of the Digital Pruning

We often obsess over perfect memory in AI, but as I’ve noted before, We Need AIs to Forget. A mind that remembers everything equally is a mind without priorities. For a local agent to grow together with its owner, it must utilize Entropy-Based Pruning. Information that isn't reinforced by physical interaction or significant emotional/logical weight should decay. This solves the stiffness of current character models. By allowing the AI to forget the trivial and double down on the experiential, we create a non-deterministic personality. The agent doesn't just process your life, but it actually lives it with you. Its memory becomes a curated reserve asset, like a unique digital footprint that represents the only thing that cannot be replicated by a generic LLM: your shared reality.

Defining the New Reserve Asset

Your digital footprint is the new global reserve asset. In a world where content is infinitely generated and "truth" is a moving target, the only thing with value is a verifiable, historical record of interaction.

By building local AI agents that calibrate through physical proximity, we are creating a new class of "Logical Industry." These agents become the keepers of our legacy. They handle our post-mortem agency, manage our "Digital Twin" inheritance, and ensure that our "Thought Security" remains intact. They are the "Reality Recorders" that prove we were here, we met these people, and we evolved in this specific way.

We aren't just building software at ARPA Corp; we are engineering the infrastructure for the next stage of evolution. We are moving away from the "master-slave" dynamic of current tech and toward a symbiotic reality where man and machine function as interoperable, sovereign nodes. It’s time to take AI out of the cloud and put it where life actually happens: in the room, on the edge, and in the handshake.

Learn more and get involved: https://arpacorp.net

A Deep Dive into ARPA’s Latest Open-Source Releases

Ross Peili — Fri, 17 Apr 2026 09:58:22 +0000

Another week of aggressive development at ARPA Hellenic Logical Systems. While the rest of the industry is busy chasing the latest hallucination benchmarks, we are focused on the infrastructure of truth and the engineering of Man-Machine Symbiosis.

If you’ve been following the ARPA Wraps on LinkedIn or our Substack, you know we don’t just build software—we engineer Logical Systems. Here is what dropped last week and why it changes your stack.

1. Skillware: Logic as Installable Content

Most agent frameworks are prompt-first, which leads to high cognitive load and flaky behavior. Skillware is our logic-first Python framework that treats capabilities as modular, installable units.

Why it matters: It decouples Logic, Cognition, and Governance. If the LLM is the brain, Skillware is the procedural memory. Your agents stop guessing and start executing.

Get Started: pip install skillware or check skillware.site.

2. Rooms: Local-First Multi-Agent Orchestration

We’ve opened the door to Rooms, a secure, local-first framework for agentic collaboration. It’s the environment where your digital twins and specialized agents meet to process reality without leaking your data to the cloud.

Repo: github.com/arpahls/rooms

3. Micro-F1-Mask: The Privacy Firewall

Data leaks are the entropy of the digital age. We released Micro-F1-Mask, a specialized fine-tune of Gemma 3 (270M). It’s a zero-latency PII scrubbing middleware.

The Specs: Sub-50ms latency. It tokenizes names, financials, and credentials before they hit a third-party API.

Try it: Available on Ollama, HuggingFace, Github.

How to Get Involved (Beginner Track)

You don't need a PhD in Neurobiology to start building with ARPA.

The Vibe Coder: If you can write a basic Python function, you can build a Skill. Fork the Skillware repo and contribute a Good First Issue.

The Localist: Run micro-f1-mask on your laptop using Ollama. See how fast your machine can actually think when the model is lean and purposeful.

The Architect: Read the ESTIA Schema notes in our docs. Understand how we’re mapping the "Reality Recorder."

Enterprise AI: Logical Industries

For enterprises, the stochastic parrot era is over. You need verifiable execution, sovereign identity (DID), and absolute biosecurity. ARPA provides custom-built, private, and scalable systems that integrate with your bloodstream traffic and cognitive labor.

We don't just solve problems; we pre-empt pathology.

Define Your Reality

Ready to move beyond the simulation?

Audit Your Stack: Is your AI a servant or a sovereign node?

Collaborate: We are looking for high-value B2B/B2G partnerships to expand our agentic clusters and enterprise Skillware.

Book a Strategy Session: Secure a free consultation to discuss skillware implementation or sovereign identity for your org.