Forem: Ross Peili

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.

A collection of high-fidelity, physics-based interactive animations

Ross Peili — Thu, 16 Apr 2026 16:48:36 +0000

Interactive Animations is a collection of high-fidelity, physics-based simulation modules designed for modern web interfaces and scientific visualization.

This repository serves as a foundational library for deploying immersive, mathematical, and organic visual components. These modules are built to be modular, performant, and scientifically accurate, suitable for integration into tactical displays, landing pages, and research dashboards.

The objective is to provide a standardized arsenal of visual assets that bridge the gap between abstract data and human perception.

Building a cool new project or a personal site?
100% Open Source
~

Animation Examples:

https://github.com/ARPAHLS/interactiveanimations/blob/main/public/quantum.gif

https://github.com/ARPAHLS/interactiveanimations/blob/main/public/stellar.gif

https://github.com/ARPAHLS/interactiveanimations/blob/main/public/hive.gif

Implementing Local MiCA Regulatory RAG for AI Agents

Ross Peili — Sat, 11 Apr 2026 11:21:19 +0000

The latest Skillware release adds a specialized MiCA compliance skill. By decoupling the statutory logic from the model, we have enabled sub-2ms regulatory lookups through an in-memory weighted router. This module allows developers to inject a standardized legal cognitive map into any LLM, ensuring agents remain grounded in real-world regulation without prompt asphyxiation or opaque tool-calling dependencies.

Check it out at https://github.com/arpahls/skillware

Stop choosing between LLM intelligence and PII compliance

Ross Peili — Wed, 08 Apr 2026 10:54:54 +0000

Choosing non-sovereign LLM inference should NOT equal the shortening of PII compliance in 2026.

Considering the latest leaks, hacks, and severe security compromises of even top-tier AI behemoths, the obvious elephant in the room is even more apparent, reminding us that data leakage is the number one barrier to pragmatic enterprise AI adoption, that is beyond fancy chatbots that farm media headlines as a KPI.

Sending raw prompts to the cloud is not only a risk of private employee data leaving your premises, but a risk that subjects the profitability and even the vitality of an entire business model.

At the same time, building basic custom filters on 70B parameter models is an unjustifiable cost, to say the least, if not straight-up absurd.

For that, we’re releasing F1 Mask, our first open weights model in the new ARPA Micro series. We're looking at a tiny 270M parameter middleware agent designed to act as a local privacy firewall. Built on the pop Function Gemma 3 base, it identifies and tokenizes Personally Identifiable Information (PII) in under 50ms before it ever hits a cloud API.

On top of that, "model template," if you'd like, we are releasing a set of scripts that will help you generate high-entropy synthetic datasets for your operational needs, train the model locally in less than 15 minutes, and evaluate its performance based on your expectations.

You can find the source code, including the tutorial on how to tailor the model to your PII needs, on GitHub: github.com/arpahls/micro-f1-mask.

If you're looking to download the weights, HuggingFace offers an Apache 2.0 version of the trained model: huggingface.co/arpacorp/micro-f1-mask.

If you wanna test the base engine before you commit, call it from Ollama via:

ollama run arpacorp/micro-f1-mask

Why it matters for Critical Infra:

💡 Zero-Latency: Sub-50ms inference on standard hardware (RTX 2070).
💡 Privacy by Architecture: Sensitive data stays in your Redis vault; the cloud only sees tokens like [INDIVIDUAL_X], [EMAIL_Y], [IBAN_Z].
💡 Highly Customizable: Ships with a synthetic generator to retrain the model on your specific industry edge cases.

Low effort, high impact, and zero PII compromise.

Why Skillware is the Next Evolution for Autonomous Agents

Ross Peili — Wed, 08 Apr 2026 08:15:50 +0000

The AI agent landscape is currently saturated with wrappers and prompt-heavy frameworks that rely almost exclusively on the LLM's ability to follow instructions in markdown files. While effective for simple tasks, this approach often falls apart when faced with complex, deterministic business logic or the need for high-stakes enterprise reliability.

This is where Skillware changes the game.

What is Skillware?

Skillware is not just another library of prompts. It is a Python-based framework designed to package intelligence as an installable unit. If an LLM is the brain, Skillware represents the procedural memory and motor functions of the agent, allowing developers to define complex behaviors, combining logic, cognition, and governance, into modular, reusable packages.

Instead of hoping an agent remembers how to interact with a specific API via a long system prompt, you install that capability into the agent's core architecture.

How It Differs: Logic-First vs. Prompt-First

Most agent frameworks are prompt-first, in the sense they provide a text-based description of a tool and ask the LLM to figure out how to use it. This creates a high cognitive load for the model and increases the chance of hallucinations as we all have experienced.

Skillware is Logic-First:

Encapsulation: Every skill is a self-contained Python module. It includes the code (Logic), the instructions (Cognition), and the constraints (Governance).
Determinism: By handling the heavy lifting of data processing and API interaction within Python, the LLM is freed to focus on high-level decision-making.
Verifiable Execution: Because skills are code-based, every action follows a predictable path that can be audited, versioned, and secured.
One of the core design goals of the framework is extreme ease of use. Setting up a new agent environment is as simple as:

pip install skillware

From there, you can initialize a workspace and begin composing agents from a library of existing skills or by building your own. The framework uses a standardized BaseSkill class, ensuring that every new capability you build is instantly compatible with any agent running the Skillware core.

Creating and Publishing Skills

Building a skill is designed to be intuitive for any Python developer. You don't need to be a prompt engineer, or have a technical background, you just need to be a light vibe coder. or possess enough transferable industry knowledge that you know would be beneficial to modern machines.

Define the Logic: Write the Python functions that perform the task.
Define the Cognition: Provide a brief manifest explaining to the agent when and why to use this logic.
Publish or Keep Private: * Public: You can contribute to the global repository on GitHub, making your skill available to the wider community.
Private: For enterprise environments, skills can be hosted in internal registries. This allows corporations to build sovereign agents that possess proprietary knowledge and internal Skillware without ever exposing that logic to the public web.

Personal Projects to Enterprise Infrastructure

Skillware is built for scale. For the hobbyist, it’s a way to make a personal assistant actually do things, say managing a local calendar or controlling smart home devices—without flaky prompt behavior.

For the enterprise, it’s a framework for Logical Systems. It allows companies to digitize their Standard Operating Procedures (SOPs) into executable skills. These skills can be deployed in closed environments, ensuring that sensitive data and critical business logic remain under strict internal control while still benefiting from the flexibility of agentic AI.

How To Get Involved

Skillware is an open-source project, and its strength lies in the diversity of its capabilities. The project is actively looking for contributors to help expand the library of available skills. You can participate with your own issues and PRs, but also by simply suggesting a skill you would like to see in the next update.

Whether you want to build a skill for blockchain interaction, bioinformatics, or simple data cleaning, the arpahls/skillware repository is open for business. We have tagged several "good first issues" for those looking to get their hands dirty with the core framework or help build out the initial skill set.

Visit skillware.site to read the documentation, or head straight to GitHub to help us define the future of modular intelligence. Let's move beyond the prompt and start building agents that actually work.

Why every AI pipeline needs a "Mask" layer (and how to build one in 5 mins)

Ross Peili — Mon, 06 Apr 2026 11:37:16 +0000

Most "AI Safety" is just vibes. But if you’re working in fintech, health, or any regulated industry, "vibes" don't pass an audit.

I’m part of the team at ARPA, and we just went public with micro-f1-mask. It’s a lightweight model designed to sit at the edge of your stack.

The Use Case: Before your user's prompt hits GPT-4 or Claude, micro-f1-mask identifies and redacts sensitive data based on your internal privacy framework.

Why this one?

Not a black box: We gave you the scripts to fine-tune it for your specific legal requirements.
Micro-footprint: Run it as a sidecar container without killing your latency.
F1 Optimized: Because in compliance, missing one piece of PII is a disaster.

Quick start here: https://github.com/ARPAHLS/micro-f1-mask

Top 10 Models You Can Train on Your Laptop in Under an Hour

Ross Peili — Mon, 06 Apr 2026 10:48:23 +0000

You don’t need a PhD or an H100 cluster to build something useful. I just mapped out 10 micro-models under 1B params you can train while eating brunch in Thessaloniki. From PII masking to vision—real tools you can own locally.

micro-f1-mask (ARPA) Released in April 2026, this is our specialized middleware for PII Scrubbing. In an age where data leaks are the new normal, the F1 Mask acts as a zero-latency filter between your raw data and the outside world. It identifies names, credit cards, and sensitive identifiers before they ever hit a third-party API.

Why Train It: Every industry has its own sensitive strings (eg. internal project codenames, emails, financial records, etc.). Fine-tuning ensures the mask is airtight for your specific domain.
How to Train: Use the synthetic_generator.py in the ARPA repository to generate a dataset of dummy PII. Fine-tuning on 5,000 samples takes roughly 15 minutes on a modern GPU using the trainer module included.
Download: huggingface-cli download arpacorp/micro-f1-mask

SmolLM2-135M (HuggingFace) A masterpiece of data curation. Despite its 135M size, it exhibits a level of common sense usually reserved for models 10x its scale. It’s the perfect brain for a lightweight agent that can run on laptops and mobile devices with no sweat.

Why Train It: To create a personal digital twin or a highly specific chatbot that knows your personal writing style or company's internal wiki.
How to Train: Use the transformers library with a simple LoRA script. Feed it your markdown notes, and it’ll learn your vibe in about 20 minutes.
Download: huggingface-cli download HuggingFaceTB/SmolLM2-135M-Instruct

Qwen 3.5-0.6B (Alibaba) The Qwen series remains the king of structured logic. If you need a model that won't break your JSON schema or forget a closing bracket, this 600M parameter model is your best friend.

Why Train It: To turn chaotic, unstructured logs into clean, machine-readable data for your complex projects and logical systems.
How to Train: Fine-tune using QLoRA with a dataset of raw text to JSON pairs. 1,000 examples will make it nearly flawless in 30 minutes.
Download: huggingface-cli download Qwen/Qwen3.5-0.6B-Instruct

Whisper-Tiny (OpenAI) At 39 million parameters, this is the most efficient Automatic Speech Recognition (ASR) tool on the planet.

Why Train It: To recognize industry-specific jargon or heavy accents that the base model struggles with (like bio-digital terminology or Greek-English technical slang).
How to Train: You only need about 30 minutes of labeled audio. Fine-tune the "head" of the model using Hugging Face's Seq2SeqTrainer.
Download: huggingface-cli download openai/whisper-tiny

MobileNetV4-Small (Google) The visual cortex of the micro-agent. It’s a lean, mean, image-classification machine that can run on a potato, let alone a laptop.

Why Train It: For specific computer vision tasks like checking if a file upload is clean or identifying hardware components in a drone feed.
How to Train: Use transfer learning. Keep the base weights frozen and train the final layer on your specific image categories. 10 minutes and you have a custom classifier.
Download: huggingface-cli download timm/mobilenetv4_conv_small.e500_r224_in1k

all-MiniLM-L6-v2 (Sentence-Transformers) This isn't for chatting, but for seeing connections. It turns sentences into mathematical vectors, enabling semantic search and deduplication.

Why Train It: If your search results are close but not quite, you can use Contrastive Learning to push related concepts closer together in vector space.
How to Train: Use the sentence-transformers library with a triplet loss function. It’s fast enough to run on a standard CPU.
Download: huggingface-cli download sentence-transformers/all-MiniLM-L6-v2

CodeGen-350M (Salesforce) A dedicated specialist in the language of logic: Code. It’s small enough to live in your IDE without draining your battery while providing surprisingly coherent snippets.

Why Train It: To learn a proprietary framework or an internal library that wasn't part of the public training data.
How to Train: Feed it your src/ directory. Even a single epoch on a few hundred files will drastically improve its auto-complete relevance for your project.
Download: huggingface-cli download Salesforce/codegen-350M-mono

Donut-Tiny (Naver/CLOVA) The "Document Image Transformer" (Donut) doesn't need OCR. It reads the image of a document and outputs structured text directly.

Why Train It: To automate the extraction of data from specific, repetitive layouts like KYC forms, invoices, or medical lab reports.
How to Train: Provide 100-200 annotated images of your specific form. It learns the geography of your document in roughly 45 minutes.
Download: huggingface-cli download naver-clova-ix/donut-base-finetuned-docvqa

Helsinki-NLP English-Greek (Tatoeba) Translation is a core pillar of collaboration. These models are tiny, offline, and outperform much larger models in their specific language pairs.

Why Train It: To handle technical or "logical industry" terminology that standard translators mangle, ensuring "Logical Systems" doesn't get translated into something nonsensical.
How to Train: Use a parallel corpus (English and Greek versions of the same text). Domain adaptation takes about 30 minutes for a few thousand sentences.
Download: huggingface-cli download Helsinki-NLP/opus-mt-en-el

Falconsai NSFW-Detector (ViT) Safety shouldn't just be a buzzword, but a security requirement. This model ensures the integrity of your incoming data streams by identifying inappropriate or malicious visual content.

Why Train It: To refine the safety threshold for your specific application, for example, teaching it to distinguish between medical bioinformatics imagery and restricted content.
How to Train: A simple classification fine-tune on a balanced dataset. It’s a Vision Transformer (ViT) architecture, which is incredibly efficient to train.
Download: huggingface-cli download Falconsai/nsfw_image_detection

Generate better Synthetic Data for Fine-Tuning with Skillware

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

One of the biggest hurdles in training local LLMs is data quality. If your training set is 90% AI boilerplate, your fine-tune will be 90% useless.

We just released the synthetic_generator skill for Skillware. It’s a modular tool that:

Orchestrates combinatorial personas to hit edge cases.
Validates data diversity using a zero-dependency entropy score.
Plugs directly into your Python scripts to build massive datasets automatically.

Run it locally with Ollama or scale with Gemini.

pip install skillware

Read the Skill Card: synthetic_generator.md

Stop Paying for Slop: A Deterministic Middleware for LLM Token Optimization

Ross Peili — Sat, 21 Mar 2026 15:46:51 +0000

Context windows are getting huge, but token budgets are tightening. Every time your agent iterates in an autonomous loop, you're potentially sending a massive, bloated prompt filled with conversational filler, redundant whitespace, and low-entropy "slop."

Today, I've merged the Prompt Token Rewriter to the Skillware registry (v0.2.1).

It's a deterministic middleware that aggressively compresses prompts by 50-80% before they ever hit the LLM.

Why does this matter?

Lower Costs: Pay only for the "signal," not the "noise."
Faster Inference: Fewer tokens mean less time spent on KV-caching and long generations.
Deterministic Behavior: Because it uses heuristics rather than another expensive LLM call, your agent behavior stays stable and repeatable.

Three Levels of Aggression

The rewriter includes three presets depending on your use case:

Low: Normalizes whitespace and line breaks (Safe for strict code).
Medium: Strips conversational fillers ("please," "could you," "ensure that").
High: Aggressively removes stop-words and non-essential punctuation (Best for machine-to-machine context).

Join the Registry

We are building a community-driven "App Store" for Agentic Capabilities—decoupling logic from intelligence. If you've built a specialized tool for LLM optimization, governance, or logic, we'd love your contribution!

Check out our Contributing Guide to get started.

I've build a secure, local-first multi-agent orchestration framework

Ross Peili — Tue, 10 Mar 2026 14:06:45 +0000

Rooms is a secure, local-first Python framework for orchestrating complex multi-agent think tanks with dynamic expertise-weighted routing.

https://github.com/arpahls/rooms

I built a modular Fraud Detection System to solve 0.17% class imbalance (RF + XGBoost)

Ross Peili — Thu, 19 Feb 2026 16:05:43 +0000

Hi everyone! I wanted to share a project I've been polishing to demonstrate how to structure a machine learning pipeline beyond just a Jupyter Notebook.

It’s a complete Credit Card Fraud Detection System built on the PaySim dataset. The main challenge was the extreme class imbalance (only ~0.17% of transactions are fraud), which makes standard accuracy metrics misleading.

Project Highlights:

Imbalance Handling: Implementation of class_weight='balanced' in Random Forest and scale_pos_weight in XGBoost to penalize missing fraud cases.
Modular Architecture: The code is split into distinct modules:
data_loader.py
- Ingestion & cleaning.
- features.py
- Feature engineering (time-based features, behavioral flags).
model.py
- Model wrapper with persistence (joblib).
Full Evaluation: Automated generation of ROC-AUC (~0.999), Confusion Matrix, and Precision-Recall reports.
Testing: End-to-end integration tests using pytest to ensure the pipeline doesn't break when refactoring.

I included detailed docs on the system architecture and testing strategy if anyone is interested in how to organize ML projects for production.

Repo: github.com/arpahls/cfd

Feedback on the code structure or model choice is welcome!