DEV Community: Ross Peili

I Cancelled Five Project-Management Subs. Here's What Replaced Them.

Ross Peili — Tue, 21 Jul 2026 12:57:29 +0000

Most of us did not set out to collect project-management subscriptions. It happened slowly: Jira for the sprint board, Asana for the client list, Notion for notes that were supposed to stay notes, something else for the timeline, and a spreadsheet because the timeline lied. Every tool wanted an account, a sync server, and a monthly line on the card. Your tasks lived in their cloud. Your focus lived in their notifications.

That stack is expensive in money and attention. You are always one login screen away from the work.

ARPA Hellenic Logical Systems just shipped HPPM — High Priority Project Manager — a local-first Windows app that treats your disk as the source of truth. No cloud. No account. No rent. Apache 2.0 on GitHub.

The pain is familiar

Modern PM tools optimize for retention, not clarity. You upload your life, pay to access your own notes, and sit through upsells while trying to finish one task. Tabs multiply. Context scatters. If the vendor changes pricing or policy, your history is hostage.

HPPM starts from a different assumption: your work should stay in plain files you can read without anyone's permission.

What HPPM actually is

HPPM is not a social network, a sync service, or an ad surface. It is a desk you spread your work on.

Your tasks live in numbered markdown trackers — 01-work.md, 02-personal.md, and so on — with priority sections, checkboxes, and titles you can edit in any editor. Metadata (tags, dates, links, notes, audit history) sits in a .hppm/ folder beside those files. Nothing phones home.

The app adds what markdown alone cannot: six views, filters, drag-and-drop, analytics, and an audit trail — all offline.

Overview for open/done/overdue at a glance. Table (sheet or list) for spreadsheet scans. Kanban by priority or tracker. Timeline as Gantt lanes or calendar. Neural as a force-directed graph of links and clusters. Fruits as a "what should I tackle next?" ranker when the list is too long to parse.

Keyboard shortcuts (? for the full cheat sheet), fourteen themes, seven UI languages, and 36 persona templates if you want a seeded project on day one — resort ops, software sprint, clinic, indie founder, and others.

How it works (without the magic)

Install the Windows app — HPPM_v026.exe from the v0.26 release.
Pick a workspace folder or create a project from a template.
Work. Drag cards, stretch timeline bars, filter by tag, complete tasks. HPPM writes back to markdown.

If the internet vanishes tomorrow, your trackers are still on your drive. Back them up like any folder. Diff them in git. Open them in Obsidian or VS Code. The app is the lens — not the landlord.

Developers can also run from source:

git clone https://github.com/ARPAHLS/hppm.git
cd hppm
npm install
npm run dev

Opens http://localhost:5173 — same UI, same API, no installer required.

Who it is for

Builders, operators, privacy-minded professionals, and anyone tired of SaaS sprawl — people who want one calm desk for priorities: offline, auditable, and free of recurring fees.

It is not for teams that need real-time multi-user sync out of the box. It is for individuals and small groups who value ownership over features that require a server bill.

Try it

Download: HPPM_v026.exe
Source & docs: github.com/ARPAHLS/hppm
Publisher: arpacorp.net

We built HPPM because project management should feel like a workspace, not a subscription. If that resonates, take it for a spin — and tell us what breaks. Contributions and suggestions more than welcome.

Agents Can Remove Image Backgrounds Locally — No Cloud API Required

Ross Peili — Thu, 16 Jul 2026 18:57:48 +0000

Are you building an agent, or are you the agent that should remove image backgrounds — product shots, portraits, uploads from chat — without wiring a separate cloud API or hoping the model “edits” pixels in prose?

Skillware has a registry skill for that: creative/bg_remover. Load it once, call execute() from any agent loop. Same skill, zero adapter rewrites across Gemini, Claude, OpenAI, DeepSeek, or Ollama.

Shipped in Skillware v0.4.5. Authored by @AyushSrivastava1818.

Skillware in a nutshell

Skillware is an open registry of installable agent capabilities — deterministic Python skills any compatible runtime can load.

Each skill is a bundle:

skill.py — execute() returns JSON; no LLM inside the handler
instructions.md — when the model should call the tool
manifest.yaml — schema, constitution, issuer, requirements
Tests and catalog docs — shipped in the wheel

You SkillLoader.load_skill("category/skill_name"), adapt for your provider, pass instructions as system context, wire tool calls to execute(). The model decides when; the skill decides how, predictably, every time.

Docs: skillware.site/documentation · agent loops

`creative/bg_remover`: what it does

Registry ID: creative/bg_remover

Catalog: bg_remover.md

Site: skillware.site/skills/bg-remover

Local background removal via rembg. Pass Base64 image data or a local file path; get a transparent PNG back with width, height, and model_used metadata.

Input	Purpose
`image`	Base64 still image (chat / upload handoff)
`input_path`	Path to a local file
`output_path`	Optional — write PNG to disk
`model`	`isnet-general-use` (default), `u2net_human_seg` for people, others
`alpha_matting`	Finer edges (hair, fur) — slower when enabled

No cloud credentials for the skill itself. Processing stays on your machine. Constitution is explicit: still images only, local-first, no storing image bytes, structured errors on bad input.

First run: rembg downloads an ONNX model (~176 MB for isnet-general-use) to the local cache. Later runs reuse it and are much faster. Provider API keys are only for the LLM loop around the skill — not for removal.

Agent vs skill

Agent (LLM + your loop)	Skill
Parses “remove the background from this product photo”	Runs rembg on bytes or a file path
Chooses Base64 vs path, model, output location	Returns `image_base64` or writes `output_path`
Shows the result to the user	Same input → same deterministic output

The model does not paint transparency. The skill does.

Try it: install and direct execute

pip install "skillware[creative_bg_remover]"

from skillware.core.loader import SkillLoader

bundle = SkillLoader.load_skill("creative/bg_remover")
skill = bundle["class"]()

result = skill.execute({
    "input_path": "product.png",
    "output_path": "product_no_bg.png",
})
print(result["success"], result.get("width"), result.get("height"))

For chat handoff, omit output_path and use result["image_base64"] from the JSON.

Try it: any agent loop

Same pattern as wallet screening, token limiting, or UK Companies House — load the bundle, expose the tool schema to your provider, call skill.execute(tool_input) on tool use:

from skillware.core.loader import SkillLoader

bundle = SkillLoader.load_skill("creative/bg_remover")
skill = bundle["class"]()
tool = SkillLoader.to_gemini_tool(bundle)  # or to_claude_tool, to_openai_tool, ...

# User: "Remove the background from product.png and save product_no_bg.png"
# On tool_call: skill.execute(tool_input)

Per-provider snippets live on the skill page and in docs/skills/bg_remover.md.

CLI smoke test after install:

skillware test creative/bg_remover

Why local matters for agents

Cloud cutout APIs add keys, latency, and data leaving your process. For ecommerce pipelines, internal tools, or agents that already handle files and Base64, offline rembg behind a fixed schema is easier to audit: one execute() contract, testable in CI, chainable with other skills in the same loop.

Pair it with monitoring/token_limiter if the agent is doing multi-step image batches — cap spend in the outer loop while the remover stays deterministic inside.

Links

If your agent touches images, load the skill before the model improvises a workflow. One line to install, one registry ID, any host.

Skillware 0.4.3 — Gemini Tool Calling, CLI, Refined

Ross Peili — Fri, 10 Jul 2026 07:37:08 +0000

Skillware 0.4.3 tightens how skills plug into Google Gemini: clearer tool objects, automatic name sanitization, and docs/examples that all tell the same story. If you are building agent loops on top of the registry, this release is mostly about making the happy path shorter and more predictable.

Gemini adapter: from dict to `types.Tool`

Earlier releases exposed Gemini tools as a plain Python dict — name, description, parameters. That worked for some quick experiments, or if you wrote your own sanitization scripts, but the google-genai SDK expects a types.Tool when you pass tools=[...] into GenerateContentConfig. In practice, copy-paste from the README or examples could fail depending on SDK version and how you wired the call.

0.4.3 changes the contract: SkillLoader.to_gemini_tool() now returns a ready-to-use google.genai.types.Tool.

Before — manual assembly in some setups

decl = SkillLoader.to_gemini_tool(bundle)
decl["name"] = SkillLoader._sanitize_function_tool_name(decl["name"])
tool = types.Tool(function_declarations=[decl])

client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Screen wallet 0xd8dA...",
    config=types.GenerateContentConfig(tools=[tool]),
)

Fine when you knew the SDK shape. Extra steps when you did not.

Now — one call, pass straight through

tool = SkillLoader.to_gemini_tool(bundle)

client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Screen wallet 0xd8dA...",
    config=types.GenerateContentConfig(tools=[tool]),
)

Same mental model as the docs always showed — load skill, adapt, call Gemini — with the adapter doing the wrapping for you.

Automatic name sanitization

Registry skills use human-readable IDs with slashes: finance/wallet_screening, office/pdf_form_filler. OpenAI and DeepSeek adapters already mapped those to underscore names. Gemini now follows the same rule.

0.4.3 sanitizes inside the loader:

finance/wallet_screening → finance_wallet_screening
office/pdf_form_filler → office_pdf_form_filler

Claude still uses slash IDs — that is by design. Gemini, OpenAI, and DeepSeek share sanitized dispatch.

When you match tool calls in a loop:

TOOL_NAME = SkillLoader._sanitize_gemini_tool_name(bundle["manifest"]["name"])

if part.function_call.name == TOOL_NAME:
    result = skill.execute(dict(part.function_call.args))

Single-tool examples that execute on any function_call keep working unchanged.

Examples, tests, and docs — aligned

Nothing under skills/ changed. The integration layer did:

Examples — All examples/gemini_*.py scripts use to_gemini_tool() directly; manual types.Tool(...) wrapping removed.
Tests — Coverage for return type, sanitization, and a catalog doc lint so Gemini snippets do not drift back to old patterns.
Docs — gemini.md, skill catalog pages, agent_loops.md, cli.md, and introduction.md describe sanitized Gemini names consistently.

Root README quick start matches runtime behavior — load, adapt, loop.

Also in 0.4.3

Contributor docs — Category selection guidance in CONTRIBUTING.md (#204).

GitHub project — Refreshed issue templates, PR template, label taxonomy, and CI sync from .github/labels.json (#227).

CLI — Same interactive experience as 0.4.2 (splash, menu, list, examples, test). Handy for browsing what ships with the package:

pip install -U skillware
skillware

Upgrade

pip install -U skillware

For Gemini:

pip install -U "skillware[gemini]"

Note for advanced callers: if you indexed the old dict return (tool["name"]), use the SDK object instead (tool.function_declarations[0].name). Standard pass-through usage is simpler after upgrade.

Any Agent Can Now Query Government Registry Data via NLP

Ross Peili — Wed, 08 Jul 2026 09:45:36 +0000

If you are building agents for financial compliance, corporate due diligence, or KYC workflows, you have probably hit the same wall: the model can talk about companies, but getting official registry data — directors, beneficial owners, filings, etc. means custom API glue, brittle prompts, and hope that the LLM picked the right legal entity.

ARPA’s latest addition to the Skillware registry — finance/uk_companies_house_handler — lets any supported model or agent query the UK Companies House Public Data API through structured tool calls. Natural language stays with the agent, HTTP, parsing, disambiguation, and UK corporate terminology stay in deterministic Python. Shipped in Skillware v0.4.1, authored by @Areen-09.

Ask “Who is the CEO of BP?” and the agent maps intent, resolves the company, fetches officers, without inventing a company number or confusing US job titles with UK registry roles.

Skillware in a nutshell

Skillware is an open-source framework for installable agent capabilities. Each skill is a bundle:

skill.py — deterministic execute() returning JSON
instructions.md — when and how the model should call the tool
manifest.yaml — schema, constitution, issuer, env vars
Tests and catalog docs — shipped in the wheel

You load_skill("category/skill_name"), adapt for Gemini, Claude, OpenAI, or others, pass instructions as system context, and wire tool calls to execute(). Same loop everywhere — see the introduction and agent loops guide.

That split is why agents prefer it over ad-hoc tool JSON or opaque skills blobs: the model decides when; the skill decides how, predictably, every time. No LLM inside the handler. No mystery middleware. One registry ID, any runtime.

`uk_companies_house_handler`: what it does

Registry ID: finance/uk_companies_house_handler

Catalog: uk_companies_house_handler.md

Six actions, one entry point:

Action	Purpose
`map_intent`	Turn keywords like “CEO”, “owner”, “shareholder” into the right UK operations
`resolve_company`	Search by name; return ranked candidates or a single match
`get_company_profile`	Status, type, SIC codes, address, charges, insolvency flags
`get_officers`	Directors and secretaries (current or historical)
`get_pscs`	Persons with significant control — UK beneficial ownership
`get_filing_history`	Accounts, confirmation statements, incorporations

Every response carries a status envelope: ready, needs_input, or error, plus fetched_at and source. Ambiguous names like “BP” return candidates, not guesses — the agent asks the user, then continues with a verified company_number.

Bundled terminology_map.yaml translates US business language into UK registry concepts (CEO → director, owner → PSC). The constitution is explicit: public data only, no filing submissions, no caching officer PII beyond the request, always cite company number and timestamp.

Setup: a free Companies House API key in .env as COMPANIES_HOUSE_API_KEY. Provider keys (e.g. GOOGLE_API_KEY) only if you run an LLM loop.

Agent vs skill

Agent (LLM + your loop)	Skill
Parses natural language	Executes HTTP against Companies House
Handles disambiguation dialogue	Returns structured candidates and next actions
Synthesizes the final answer	Maps intent keywords to operations

The skill does not replace your compliance analyst — it equips the agent with the same structured lookups an analyst would run, at machine speed, auditable step by step.

Try it: direct execute

from skillware.core.loader import SkillLoader
from skillware.core.env import load_env_file

load_env_file()
bundle = SkillLoader.load_skill("finance/uk_companies_house_handler")
skill = bundle["class"]()

result = skill.execute({"action": "resolve_company", "query": "BP", "limit": 5})
print(result["status"], result.get("candidates"))

Try it: intent → officers pipeline

intent = skill.execute({
    "action": "map_intent",
    "intent_keywords": "CEO, director",
    "entities": {"company_query": "BP"},
})
officers = skill.execute({
    "action": "get_officers",
    "company_number": "00102498",
    "active_only": True,
})

Try it: full Gemini loop

Runnable scripts ship in the repo:

pip install -U skillware
python examples/uk_companies_house_handler_demo.py
python examples/gemini_uk_companies_house_handler.py

The demo script is mocked (no API key). The Gemini example needs GOOGLE_API_KEY and COMPANIES_HOUSE_API_KEY.

Outro

Government registries are not chat-native. They are API-native, jurisdiction-specific, and unforgiving about entity resolution. finance/uk_companies_house_handler turns that into a plug-and-play Skillware bundle: load once, chain with screening or token-budget skills, run on any model you already use.

Links

Questions and skill ideas welcome in the repo. If your agents touch UK corporates, start here — before the model freelances a company number.

Quantum Is Less About Physics & Math, And More About You

Ross Peili — Sat, 04 Jul 2026 16:52:02 +0000

The uncertainty that comes with Quantum Mechanics is the gift, not the problem that many career scientists are desperately trying to solve for a resume update.

I was sitting in a coffee shop in Moscow last week, eavesdropping on a conversation between two founders. One was pitching something like “quantum breeding of DNA strands for faster desirable results in synthetic plants and foods,” while the other nodded along, sipping his oat milk latte, as if it were the most natural thing in the world, nobody blinked, nobody said, “wait, you’re telling me your software relies on particles being in two places at once?” or whatever, they just… accepted it, as if it was natural.

Now, I might not be considered a Quantum expert if you'd ask self-proclaimed LinkedIn experts in the domain, but I didn't have to be one in order to realize the obvious fact that the quantum revolution already happened. Not in a lab, or a press release from IBM or Google or whatever. It happened quietly, in the collective psyche of people who have never solved Schrödinger’s equation, never touched a dilution refrigerator, and probably couldn’t tell a qubit from a cucumber. The true, practical, real-time effect of quantum on society isn’t a faster computer, but that we’ve all been gently forced to believe that the impossible is not only possible, but probably the default state of what we refer to as "reality" atm. And that changes everything, for everyone.

Hear me out, or better, think about what quantum mechanics actually asks of you. It asks you to accept that a particle doesn’t have a definite position until you look at it. That two particles separated by a galaxy can somehow “know” about each other’s state instantly. That a cat can be dead and alive at the same time, and no, it’s not a metaphor, it’s a serious thought experiment that scientists use to illustrate how the universe might actually work. For a species that spent centuries copy-pasting writings about evolution and pretending we came from monkeys, this isn’t just a scientific update, but more like psychological shock therapy.

When Newton published the Principia in 1687, he gave us a cosmos that was orderly, predictable, and sane. Cause led to effect. If you knew the position and velocity of every atom, you could predict the entire future. Pierre-Simon Laplace later made it a philosophical doctrine: a demon with enough information could know all that was, is, and ever will be. That view shaped the Enlightenment, the Industrial Revolution, and the very architecture of our minds. We came to believe in a reality that, even if complicated, was fundamentally knowable. That’s the crib we grew up in by default.

Then quantum mechanics pulled the rug out from under the crib, the floor, and the very concept of “under.”

The pioneers of quantum theory were the first to be psychologically pummeled by it, eg. take Werner Heisenberg, who formulated the uncertainty principle, and said “I repeated to myself again and again the question: Can nature possibly be as absurd as it seemed to us in these atomic experiments?” or Niels Bohr, who famously remarked, “Anyone who is not shocked by quantum theory has not understood it.” Einstein, even tho I have little respect for his narrators, until his death, called it “spooky action at a distance” and insisted, “God does not play dice.” Thinking they were the smartest people in the room, it would feel weird for a common NPC to analogize that they were grappling with a reality that felt like a betrayal of reason itself as we know it.

The Only Quantum Supremacy That Matters Is Inside Your Head

Now, fast forward a century, and that very absurdity has seeped out of the textbooks and into the water supply of our very culture. You don’t need a physics or math PhD, or whatever, to talk about the multiverse. The phrase “quantum leap” is used to sell fkn self-help courses. People casually describe relationships as “entangled” or talk about “manifesting” reality by observing it, a rough, pop-spirituality echo of the observer effect. So, it has nothing to do with accurate science, yet it’s a profound symptom of it. Maybe the wildest, most counterintuitive ideas ever validated by experiment have become part of the mental furniture of ordinary life, and we’ve not only stopped resisting the bonkers, but we’ve started building our entire identities around it.

This is the real quantum supremacy, if you ask me: not a machine that beats a classical computer at a rigged benchmark, or on the paid PR headline, but a quiet, sweeping shift in what the human mind is willing to consider as real.

The hard science is important, of course, for those who actually understand it, meaning those who understand they will never understand it, those who start bringing God into the equation more often as they dive deeper into the path of understanding, even if they rejected such blatant descriptions of reality in the past.

The mathematics is so abstract that, as Richard Feynman said, “I think I can safely say that nobody understands quantum mechanics.” He didn’t mean nobody can use the equations, but that the picture of reality behind them defies our evolved intuitions. We are a species, especially the current spectrum of everyone alive, that learned to survive by waiting for the bus, paying taxes, and watching TV, not by computing probability amplitudes in an infinite-dimensional Hilbert space. Yet here we are, collectively internalizing that the substrate of everything, the reason your body holds together, the reason the sun shines, the reason you can read these words on a computer screen, operates on principles that would make a medieval theologian blush like a tsundere fan of a typical harem anime protagonist.

Quantum Mechanics As A PsyOp

And this is where the philosophical pivot lands, right now, today. People who were once stubborn materialists, who prided themselves on “seeing is believing,” are finding it increasingly difficult to hold that line. Quantum mechanics, without their permission, has dismantled the notion that reality is just tiny billiard balls bouncing around. It has smuggled in mystery at the ground floor. The most rigorous, empirically tested theory in history tells us that at a fundamental level, things don’t exist in a definite state, but more like a cloud of possibilities until an interaction occurs. “We are not passive observers of an objective reality,” wrote physicist John Archibald Wheeler. “We are participants in the construction of the world.” That is not a slogan from some feminist rights poster, but literally a pillar of modern physics.

The effect on our psychology is immense, and it’s happening whether we acknowledge it or not, like a low-frequency hum that’s slowly retuning our expectations. If the universe is deeply, irrevocably weird, say if it allows for non-locality, superposition, and genuine indeterminism, then the rigid boundaries we drew around what is “impossible” in our personal lives, in society, in our conception of the future, start to soften. If particles can tunnel through barriers that classical physics says are insurmountable, might there be a way through our own? If observation brings potential into actuality, what role does attention play in shaping our days? This isn’t magical thinking, but a natural, almost inevitable, extension of accepting the implications of our best science.

And again, there are those who would sooner accept that we emerged from monkeys or whatever, over millions of years of random, unexplained occurrences, than entertain even the faintest possibility of anything beyond what the TV, Insta, or a NASA press release has handed them as ready-to-swallow intel. It doesn't just scare them or repel them, the notion that we might inhabit something like a server, that we are organic information processors, let alone the extension of that thought into realms where words like "God" become unavoidable.

Even when voices as scattered across history as Feynman, Tesla, and Socrates all point in the same direction, that humane units are information processors, that reality is a predefined construct, that thought can alter the physical and not just if you "know how frequencies work", etc. people still wave it away. What's ironic is they dismiss it by saying, "that's not scientific", or whatever, as if science would exist without these very minds, that by the way, all pointed toward God, all recognized that intelligence is artificial by nature, including ours, and all suspected the environment we inhabit is pre-designed. The even deeper irony? Ask these same defender NPCs of scientific purity to name any scientific theory, and they scratch their head. They don't understand science. They just use it like a get-out-of-jail-free card whenever they're confronted with a reality they cannot accept, or, more accurately, a reality they cannot even comprehend as a concept.

History shows that shifts in cosmology reshape the human self-portrait, eg. Copernicus moved us from the center of the universe, Darwin connected us to all life, Freud revealed an unconscious we didn’t control, etc. and each time, the initial response was denial, then a slow, deep reweaving of the cultural fabric. Quantum is the latest and most disorienting chapter. But unlike the previous ones, its strangeness isn’t a far-off fact about stars or fossils or dreams. It’s woven into the chips in our phones, the lasers in our hospital scanners, and the cryptographic keys that secure our emails. We can’t dismiss it as abstraction. We use it every second, and so we are, in a very real sense, brushing up against the impossible with every tap of a screen. We literally live in a world where "scrolling", "taxes", "cars", are considered normal, human, natural even.

What I see around me, or what prompted that coffee-shop epiphany, is a generation that despite all the talk of political polarization and post-truth, is incubating a radical new tolerance for the preposterous. Not in a cynical, “facts don’t matter” way, but in a genuinely open, epistemically humble way. If a particle can be a wave and a particle, if an effect can precede its cause at the quantum level, if the act of looking determines what is seen, then maybe the world is far more plastic, more relational, and more mysterious than the old Newtonian model allowed. This doesn’t make people abandon reason, but forces them to expand the definition of what reason can accommodate.

The commercial quantum narratives, the hype cycles, the geopolitical scrambles for “supremacy”, they are surface ripples, while underneath them is a deeper, human story, our story.

We are learning, collectively, to live with uncertainty not as a temporary nuisance but as the permanent ground of being. The philosopher Kierkegaard wrote of a “leap of faith” required to live meaningfully in a world without objective certainty. A century of quantum physics has made that leap not just a religious or existential choice, but a scientifically literate one. We are tuning into a state of mind where the unexplored, the unacceptable, the “that can’t be right” become not only real but an acceptable part of who we are.

That is the gift of quantum right now, and it's not a timeline to a mythical quantum computer that will crack all encryption or hack your bloody bitcoin wallet or whatever, but a daily invitation to hold our certainties more lightly. To listen to an outlandish startup pitch, or a friend’s improbable dream, or even an opposing political view, and think: well, if the electron can do it, maybe there’s a possibility here I can’t yet see. The most stubborn non-believer, the one who never opened a science book, is already being shaped by this. They just don’t call it quantum. They call it a hunch, a change of heart, or a moment of unexpected grace. I mean, we live in a time where Biden managed to become the president of the US, pedos are literally proud about it on TV, and NPCs genuinely think that paying taxes is their personal choice. I assure you, if that's possible, everything is possible.

Conslusion and my two cents
The real quantum supremacy, then, is a quiet mind that no longer needs the universe to be a machine in order to feel safe in it. And that, more than any billion-dollar qubit, is what will decide how we operate and look into the future.

A decade ago, I was describing, with a clarity that still unsettles me, the exact reality we now inhabit, everything from personal AI and quantum apps beyond theory, to remote genetic engineering, and mandated biotech trackers, you name it. Not because I'm a prophet or got lucky, but simply because I was certain.

Everyone around me wished, hoped, craved, from flying cars to cured diseases, a return to nature that was against their lifestyle and obvious trajectory, to paper or screen backed wealth they thought would solve all their concerns. Things they wanted but were unsure they'd ever have. A gamble, a constant stress that leads to inevitable disappointment. I knew what was coming because the sequence was already set. All I had to do was read the first domino, and it showed me where the last would fall. Arguing in between is like a grandma yelling at a movie that has already been printed and running.

Certainty shapes reality. A man without belief is no longer master of his thoughts, and therefore no longer author of his world. People who argue about God, quantum, science they don't understand, they're uncertain. Of everything. Their reality, themselves. If you expect these NPCs to agree with you, or tell you what is real, you've already lost your power to dictate physical and digital reality at will.

How LLMs Now Monitor and Cut Their Own Token Spend

Ross Peili — Tue, 30 Jun 2026 15:29:53 +0000

You have seen this loop before.

An agent starts a “simple” task, say scrape listings, refactor a repo, research a market, or whatever. It fails, it retries, it re-reads context, it apologizes and tries all over again. Twenty minutes in and the dashboard shows six figures of tokens and zero useful outputs or deliverables.

The model did not misbehave on purpose. The orchestrator never had a hard budget gate with an ROI in mind.

Skillware v0.4.0 ships a new skill for exactly that gap: monitoring/token_limiter. It lets you monitor and limit any agent’s token budget in real time — Gemini, Claude, OpenAI, DeepSeek, Ollama, custom Python loops, you name it. Same skill, same JSON, any runtime.

What Skillware is in a nutshell

Skillware is an open registry of installable agent capabilities. Each skill is a bundle:

skill.py — deterministic Python (execute() returns JSON)
instructions.md — when the model should call the tool
manifest.yaml — schema, constitution, issuer
Tests and docs — shipped in the wheel

You load by ID, adapt for your provider, call execute() on tool use. The model decides when, the skill decides how, predictably, every time.

That split matters for budget control. You do not want the LLM guessing whether it is “allowed” to spend more tokens. You want a small, auditable function that answers: continue, warn, or stop.

Meet the `Token Limiter`

This skill is a budget gate, not a kill switch wired into OpenAI or Anthropic.

After each model turn, your host loop passes cumulative usage. The skill returns one of three actions:

Action	Meaning
`CONTINUE`	Under the soft threshold — keep going
`WARN`	Approaching the limit (default 80%) — tighten scope
`FORCE_TERMINATE`	Hard ceiling hit — stop the loop

Important nuance: the skill does not cancel API sessions or kill processes. It returns a structured decision. Your orchestrator must act on it. That is by design — Skillware skills stay portable and provider-neutral.

No skill-specific API keys. No network calls. Pure Python math on numbers you supply.

How it works in a real loop

Picture a scrape task with a 100,000 token ceiling.

Agent runs turn 1 → host adds usage → calls token_limiter
Turn 2, turn 3 — same pattern
At 85k tokens → WARN
At 105k → FORCE_TERMINATE → host breaks the loop and surfaces the reason

Minimal integration:

from skillware.core.loader import SkillLoader

bundle = SkillLoader.load_skill("monitoring/token_limiter")
skill = bundle["module"].TokenLimiterSkill()

result = skill.execute({
    "task_id": "scrape_listings_101",
    "current_token_count": 125_000,
    "max_allowed_tokens": 100_000,
    "model_id": "gpt-4o",
})

if result["action"] == "FORCE_TERMINATE":
    raise RuntimeError(result["reason"])

The host tracks cumulative current_token_count from whatever provider you use — usage metadata from the API, a local tokenizer, or your own accounting layer. The skill does not read billing dashboards for you.

Optional model_id maps to bundled list prices for indicative USD in the response. Handy for ops dashboards; not invoice-grade. Unknown models fall back to a blended rate with a warning in the payload.

Optional turn_id makes retries idempotent: same turn, same counts, same decision — no double-penalty if your loop replays a step.

Architecture: Mind, Body, and a new category

The skill lives under a new monitoring/ category — room for more observability skills later.

budget.py — pure evaluation logic (thresholds, cost estimate, ROI scaffold for v2)
skill.py — thin BaseSkill wrapper, in-memory turn cache
instructions.md — tells the agent: call this every turn; stop when you see FORCE_TERMINATE
data/model_pricing.json — indicative rates for common models

v1 enforces token limits only. ROI fields (expected_outcome, outcome_delivered, roi_value_usd) are accepted as scaffold for v2 — outcome-aware gates later, without breaking the v1 contract today.

Runnable examples ship in the repo: local loop simulation (token_limiter_loop.py), plus Gemini and Claude harnesses. Install and try:

pip install skillware

Catalog page: docs/skills/token_limiter.md

Chain it with other skills

Budget control pairs naturally with optimization/prompt_rewriter — compress bloated context before the main call, then cap spend during the loop. Less waste in, hard ceiling out.

Running agents against contracts or wallets? Screen first with finance/wallet_screening, execute with defi/evm_tx_handler, and keep token_limiter in the outer loop so a stuck DeFi agent cannot burn budget forever. Three skills, one NLP-driven pipeline, any supported model.

Conclusion

Autonomous agents without token guardrails are expensive experiments. monitoring/token_limiter gives you a deterministic, testable answer to a simple question after every turn: are we still within budget?

It ships in Skillware v0.4.0 today. Load it once, wire it into your loop, and stop paying for agents that retry themselves into oblivion.

Links

Questions, issues, or skill ideas welcome in the repo. If you are building agent infra, start with a budget gate — your finance team will thank you later.

Any Agent or LLM Can Now Own A Wallet and Perform EVM TXs via NLP

Ross Peili — Mon, 29 Jun 2026 19:04:40 +0000

Your agent can own a wallet now — natural language to on-chain swaps on Ethereum, Base, and other EVM chains.

Most agent demos stop at reading the chain. You ask about a token, the model summarizes a blog post, everyone claps, and nothing moves on-chain.

The new defi/evm_tx_handler skill in Skillware is aimed at a different loop: your agent holds its own EVM wallet, turns plain-language trade intent into structured JSON, quotes a Uniswap V2 swap, shows a preview, and — only after confirmation — signs and broadcasts. No MetaMask popup. No pasting calldata into a block explorer. The LLM stays in natural language; the skill stays deterministic Python.

This post walks through what that looks like in practice, how Skillware fits in, and how you might chain it with wallet screening before you send funds anywhere sketchy.

Skillware in a nutshell

Skillware is an open-source Python framework for packaging agent skills the way you’d package a small library: one folder, one contract, works across providers.

Each skill is a bundle:

skill.py — deterministic logic (execute()), no hallucinated math
manifest.yaml — tool schema, env vars, constitution
instructions.md — how the model should use the tool (flows, edge cases, safety)
test_skill.py — bundle tests that run in CI

You load a skill once, adapt it for Gemini, Claude, OpenAI, or others via SkillLoader, pass instructions.md as system context, and wire tool calls to skill.execute(...). Same pattern everywhere — see the introduction and agent loops guide.

That separation matters for DeFi: the model parses “Buy 10 DEGEN on Base with USDC”; the skill parses nothing in free text. It only accepts structured action + intent and returns JSON the agent can show to a human.

`evm_tx_handler`: architecture in plain terms

Registry ID: defi/evm_tx_handler

Issuer: @Hendobox · catalog page

The skill is built around a dedicated agent wallet — not your personal MetaMask, not a treasury. You create a fresh key, fund it lightly, and put it in .env as AGENT_WALLET_PRIVATE_KEY. The constitution is explicit: “Never pass keys in tool args, YAML, or logs.”

Under the hood, EvmTxHandlerSkill loads YAML registries from data/:

chains.yaml — today Ethereum mainnet and Base (chain IDs, RPC env keys, verified Uni V2 router addresses)
tokens.yaml — symbol → contract per chain
addressbook.yaml — human labels → addresses for transfers

Long-term defaults (default chain, slippage, confirm_before_send, max_trade_usd) live in config.yaml (copy from config.yaml.example).

Agent vs skill (the split that keeps you sane)

From the skill’s instructions.md:

You (agent)	Skill
Parse natural language into partial `intent` JSON	Merge intent with config and YAML registries
Ask for missing fields in plain language	Return `missing_fields` and `suggested_defaults`
Show `preview` to the user and obtain approval	Build on-chain quotes; sign swaps and transfers when confirmed
Pass `confirmed: true` after approval	Approve (if needed), swap, or transfer; return tx hash + receipt

So the NLP layer is the LLM. The signing layer is Web3.py inside the skill, using the agent wallet key from the environment — not from the chat thread.

Actions you actually call

The manifest defines eight operations: resolve, quote, preview, execute, transfer, balances, wallet_info, update_preferences.

A typical buy flow (from the skill docs):

User: “Buy 10 Degen on Base with USDC.”
Agent calls resolve with intent like:

{
    "side": "buy",
    "chain": "base",
    "target_asset": "degen",
    "amount": 10,
    "amount_kind": "target_out",
}

If spend_asset is missing, the skill returns missing_fields — the agent asks the user, then continues.
quote / preview — live Uni V2 math, optional USD via CoinGecko if you set COINGECKO_API_KEY.
User approves in plain language.
execute with the same intent and confirmed: true.

Important nuance (easy to miss): execute re-quotes on-chain at broadcast time. Preview amounts can drift. The skill warns you to call quote or preview immediately before confirmation — not five minutes earlier.

For ERC20 spends, you may get a two-step flow: approve tx, then swap. If the response includes approve_tx_hash, tell the user both hashes landed.

Copy-paste: load the skill and run a Gemini loop

Install Skillware and deps (web3>=6), set RPC URLs and the agent wallet key, then:

import os
import google.genai as genai
from google.genai import types
from skillware.core.env import load_env_file
from skillware.core.loader import SkillLoader

load_env_file()
bundle = SkillLoader.load_skill("defi/evm_tx_handler")
skill = bundle["module"].EvmTxHandlerSkill()
client = genai.Client()
tool = SkillLoader.to_gemini_tool(bundle)

intent = {
    "side": "buy",
    "chain": "base",
    "target_asset": "degen",
    "spend_asset": "usdc",
    "amount": 10,
    "amount_kind": "target_out",
}

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Resolve and quote a buy of 10 DEGEN on Base with USDC.",
    config=types.GenerateContentConfig(
        tools=[tool],
        system_instruction=bundle["instructions"],
    ),
)
# On function_call: skill.execute({"action": ..., "intent": ...})
# After preview + user approval:
# skill.execute({"action": "execute", "intent": intent, "confirmed": True})

No keys in the prompt. No MetaMask. The model never sees your private key — only the skill reads AGENT_WALLET_PRIVATE_KEY from the environment.

Want to try the flow without mainnet? The repo ships runnable examples:

EVM_TX_HANDLER_EXAMPLE_DEMO=1 python examples/gemini_evm_tx_handler.py

See examples/gemini_evm_tx_handler.py and examples/claude_evm_tx_handler.py in the examples index.

Safety rails (built into the skill, not bolted on later)

A few things the skill enforces so agents don’t YOLO on-chain:

confirm_before_send — execute / transfer blocked until confirmed: true
Balance pre-checks — insufficient funds return status: insufficient_balance before broadcast
max_trade_usd — fail closed if USD price unavailable when a cap is set
Constitution — dedicated wallet only, not financial advice, fail closed on missing RPC or registry entries

The skill itself recommends pairing with finance/wallet_screening before large sends to unknown addresses — screening runs locally in one execute() call (sanctions, malicious interaction counts, PnL context). That’s a natural chain: screen a recipient or counterparty wallet first; only if the report looks acceptable, call transfer or execute on the tx handler.

Same agent loop, two tools, one conversation:

User: “Send 0.5 ETH to 0xABC… but check if it’s safe first.”
Agent calls wallet_screening with the address.
Agent summarizes summary.sanctioned_entity_match, summary.malicious_interaction_count, etc.
If clean (and user still wants to proceed), agent calls evm_tx_handler → transfer with preview → user confirms → confirmed: true.

Both skills load through the same SkillLoader pattern; you’re composing capabilities, not rewriting provider-specific tool JSON from scratch.

Limits (honest ones)

Today this skill is Uniswap V2 only, on Ethereum + Base (see data/chains.yaml). No bridges, no aggregators, no Polygon router in the registry yet — adding chains is a YAML + verification exercise, not magic NLP.

Natural language can still be mis-parsed. Preview drift is real. Market risk is real. The skill gives you structure, signing, and guardrails; it doesn’t replace human judgment on whether a trade makes sense.

Where to go next

Skill source: skills/defi/evm_tx_handler
Docs: evm_tx_handler.md · API keys
Framework: github.com/ARPAHLS/skillware · pip install skillware
Site: skillware.site

If you’ve been wiring one-off Web3 tools per provider, this is the other path: one skill bundle, any agent, one wallet the agent actually controls — with previews, confirmations, and screening chained in when you need them.

Skillware Crosses 8,000 OS Deployments and Goes Enterprise

Ross Peili — Mon, 29 Jun 2026 07:52:36 +0000

Numbers reflect adoption, but architecture dictates reality. As of this week, the open-source releases of our Skillware packages have surpassed 8,000 downloads across PyPi, according to [PyPI Stats (https://pypistats.org/packages/skillware) and PePy.

For those who have been tracking our commits at ARPA, you know the premise of Skillware was never about simply wrapping standard LLM APIs. We are engineering installable intelligence—modular, agentic AI microservices designed to give autonomous models the concrete ability to execute complex, verifiable actions across legacy systems. The first phase was about establishing the baseline. We deployed the atomic functions, and the developer community battle-tested the logic.

Now, we elevate the stack.

The baseline is stable. The next phase for Logical Industries requires shifting from atomic open-source functions to deeply chained, enterprise-tier cognitive workflows. We are moving beyond models that merely synthesize information, toward agents that structurally optimize operational reality.

The Transition to Enterprise Skillware

Standardization is the enemy of competitive advantage. To build the infrastructure for true man-machine symbiosis, AI agents must possess highly specialized, industry-specific capabilities. Whether it is a compliance model cross-referencing KYC documentation with steganographic malware checks (similar to our deployments for the financial and compliance sectors), or a financial agent executing multi-layered smart contract audits, the demand for sophisticated "skill chaining" is absolute.

We are not guessing what the industry needs. We are extracting the parameters directly from the source.

Initiating the Vanguard Cohort

To architect the first wave of Enterprise Skillware, we are opening a closed co-development cycle with our closest network partners and top-tier industry operators. We call it the Vanguard Cohort.

The protocol is straightforward: We want to identify the heaviest friction points and operational bottlenecks within your specific sector—be it Web3, bioinformatics, logistics, or decentralized finance.

Tell us the exact, native AI capability that would fundamentally upgrade your workflow. If your proposal defines a critical industry gap, ARPA will engineer, chain, and implement that custom skill for your internal agents entirely at zero cost. Furthermore, your organization will be permanently integrated and credited as a co-author of the skill.

We engineer the bypass; you keep the operational leverage.

How to participate:
If you operate at the enterprise level and have a precise bottleneck that requires an algorithmic solution, submit your operational parameters via the secure brief below.

Fill the cohort form

The era of generic AI is closing. The future belongs to custom, self-executing logic. Define reality.

Simulating Antiferromagnets with PennyLane: A Deep Dive into spinq-vqe

Ross Peili — Fri, 26 Jun 2026 05:32:08 +0000

Quantum Machine Learning (QML) is rapidly moving from theoretical whitepapers into practical engineering pipelines. If you are curious about how quantum algorithms actually interface with material science, the newly open-sourced spinq-vqe repository from ARPA's QONDRA division is a perfect sandbox.

Built entirely in Python using PennyLane, spinq-vqe tackles the quantum many-body physics of Mn₃Sn. For context, Mn₃Sn is a Kagome antiferromagnet that recently demonstrated ultra-fast 40-picosecond spin-orbit torque switching. Simulating the ground state of its highly correlated Kagome lattice is notoriously difficult for classical systems, making it an ideal candidate for quantum variational methods.

Here is a breakdown of what makes this repository worth cloning, whether you are a QML researcher or a classical software engineer looking to bridge the gap into quantum systems.

1. VQE and the Barren Plateau Problem in the Wild

One of the most valuable aspects of this repo is its transparent handling of algorithmic bottlenecks. In notebooks/02_vqe_run.ipynb, the pipeline attempts to find the system's ground state using a Variational Quantum Eigensolver (VQE) with a Hardware Efficient Ansatz (HEA).

If you run the simulation using a standard Adam optimizer, the training completely stalls out. Why? The initial $|0\rangle^{\otimes N}$ state is a Z-basis eigenstate. Due to the SU(2) symmetry of the Heisenberg Hamiltonian, the quantum gradients cancel out to exactly zero, trapping your model in a barren plateau. The repository demonstrates how swapping to COBYLA—a gradient-free optimizer that evaluates the cost function directly—neatly bypasses this trap, achieving a 9.66% error rate against Exact Diagonalization (ED) on a 9-qubit system.

2. Hybrid Quantum-Classical Material Screening

Quantum computing doesn't exist in a vacuum, and this repository showcases a brilliantly practical hybrid pipeline in notebooks/04_soc_qaoa.ipynb.

To screen materials for optimal Spin-Orbit Coupling (SOC), the pipeline first trains a classical Multi-Layer Perceptron (MLP) to predict spin Hall angles. This classical model then acts as an oracle for a Quantum Approximate Optimization Algorithm (QAOA). At a shallow circuit depth of $p=2$, the QAOA successfully converges on the optimal global material trio: Mn₃Sn, CrTe₂, and Bi₂Se₃. It’s a clean blueprint for blending classical ML with quantum optimization.

3. Entanglement Profiling

The Kagome lattice is famous in physics for hosting quantum spin liquids. The spinq-vqe source code includes robust modules to calculate Von Neumann entropy and mutual information, allowing you to mathematically verify the strong, non-local quantum correlations across the sublattices directly from your simulated statevectors.

Get Started

The architecture is clean, highly modular, and heavily documented. You can read the full physics background, ansatz guides, and API documentation in the /docs directory.

Further Reading & Literature

The methodology implemented in this codebase relies on foundational quantum mechanics and QML literature. Key citations operationalized in the repo include:

Cerezo, M. et al. (2021). Cost function dependent barren plateaus in shallow parametrized quantum circuits.
Farhi, E. et al. (2014). A Quantum Approximate Optimization Algorithm.
Kandala, A. et al. (2017). Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets.
Yan, S., Huse, D. A., & White, S. R. (2011). Spin-liquid ground state of the S=1/2 Kagome Heisenberg antiferromagnet.

Check out the code, run the notebooks, and see firsthand how quantum simulations are mapping the spintronic hardware of tomorrow.

[Boost]

Ross Peili — Mon, 15 Jun 2026 14:30:42 +0000

Ross Peili

May 29

Skillware Just Dropped a Skill That Lets Your Agent Solve Any GitHub Issue in One Prompt

#skillware #agentskills #arpa #localai

5 min read

Our OS AI skills framework is actually getting some heat - new contributors welcome <3

Ross Peili — Mon, 15 Jun 2026 07:51:55 +0000

Today, we released Skillware v0.3.6, Skillware is basiclaly an open-source framework for packaging Python capabilities (wallet screening, PDF tools, compliance checks, etc.) as skills agents call via normal tool APIs, instead of generating one-off code each time.

This release is mostly contributor-facing: CLI works out of the box (pip install skillware, python -m skillware fallback), clearer help, CI runs bundle tests under skills/, and a small wallet_screening fix, and this made me pause for a moment and be grateful of all the contributors and what we've built.

Today, we have over 40 stars and 12 contributors from all over the world. I know it might sound like nothing to some, but we started from zero, and slowly built this upwards together. I won't explain here why Skillware is better than agent skills, you can check the docs or read articles about it, but I wanna share why I am so excited about these numbers, even tho again, to some they might sound non worthy of hype.

Initially, we built skillware having machines in mind. Most people are building AI, apps, services, tools, products, targeting humans. But in 2026, AI is your core audience, the one that makes up more than half of the internet traffic. I mean, even when humans dyor they essentially employ an AI to do the search, even when you google things, AI is replying. So, the idea was to make Skillware easily accessible, discoverable, parsable, testable, and usable by LLMs and AI Agents with 0 friction.

We built the website in a way that makes it easy for agents to find, browse skills, find skills they need, and use them out of the box with one code block, no matter which model or framework they are coming from.

On top of that, our repo is not only AI friendly, but AI focused. YES! we expect that everyone is using AI tools, code assitsants and AI enabled IDEs. There is no excuse to not do it in 2026. Our repo is build in such a way, that literally any agent or model can understand it instantly and start solving issues with single shots, without back and forths, without breaking files, or ignoring important ripple effects or complementary files etc.

I take this moment to celebrate Skillware. Even if I am celebrating alone ❤️ and I would like to welcome anyone who wants to contribute to open source AI, or sharpen their python skills to join us and give it a spin, not just a project/tool, but also as modern clean cut repo tailored for agents at work. Lots of good first issues, as well as complex and sophisticated skill bundles that are not just silly md prompts.

You can check the repo at arpahls/skillware, install with pip install skillware, or visit skillware.site

Skillware Just Dropped a Skill That Lets Your Agent Solve Any GitHub Issue in One Prompt

Ross Peili — Fri, 29 May 2026 10:27:54 +0000

I Let Two AI Agents Fix the Same GitHub Issue, One Took 7 Tries, the Other Nailed It in One Shot

Yes, I know. Most of us already use AI coding tools. Cursor, Antigravity, you name it, they're all pretty good at autocompleting a function or generating a quick boilerplate. But here's the thing: I tested Claude 4.7 Opus via Cursor, and a local Qwen 3.5 running through Ollama, which was also armed with Skillware's new Issue Resolver skill. The results were shockingly surprising, and I genuinly did not expected that myself.

The setup

I grabbed a real GitHub issue, not a trivial typo fix, but a moderately complex bug that touched several files, had downstream ripple effects, and required documentation and versioning updates that weren't obvious from the issue description alone. So you would normally have to manually dig deeper, compare changes, etc. The kind of thing where the fix itself is straightforward, but getting it right means touching half a dozen places most people, and even AI IDE agents would overlook.

Then I let both agents take a crack at it.

Claude Opus went first, and it did fine. Eventually.

Opus dived in exactly how you'd expect a capable but eager junior dev to behave. It read the issue, found the most obvious place to patch, and implemented a minimal fix. Good. But then I noticed it hadn't updated the tests. So I had to do a follow up prompt. Then it forgot the docs. Another prompt. Then I spotted a version bump that should've happened. Prompt again. Then a related config file that referenced the changed behavior. Another prompt, and you get the gist.

All in all, it took seven back-and-forth exchanges to get everything right. Each iteration was fast, and the code quality was solid, but I had to steer the ship manually after every step. Opus wasn't thinking holistically. It was treating the issue like a surgical strike on one file, blind to everything else that needed to change. That's not a Claude problem, buw what happens when an agent jumps straight to implementation without pausing to think. Sure it had an implementation plan and parsed the repo and all, before working, but still didn't sweep everything as expected. At least not without micromanaging it like a corporate watchdog.

Then Qwen 3.5 with Skillware had a go

Same issue. Same repo. But this time, the agent was using Skillware's Issue Resolver, a new skill that forces a structured analysis phase before any code gets written. Instead of rushing to the fix, the agent first fetched the issue, read the repo's readme, code of conduct, contributing, etc, scanned the directory tree, and mapped every file that could possibly be affected.

Then it didn't just presented a plan. Here's what's broken. Here are the acceptance criteria. Here are the files that need to change, including tests, docs, config, and downstream modules you might not have thought about. Here are three ways to fix it, ranked by risk and complexity. I picked one, approved it, and the agent implemented the whole thing in one go, including local testing, linting, formatting, and all the complementary changes that would make it sail through a PR review instantly. It also created a branch, ensured there are no co authors in commit, pushed the commit, all in one go.

One shot. No nudges. No "oh wait, you forgot the..."

And here's the part that matters: this isn't about Qwen being better than Claude or whatever model fights make up the headlines these days. Don't get me wrong, Opus is an incredible model. The difference was entirely in the workflow. Opus without Issue Resolver behaved like a brilliant developer who skipped the planning meeting. Qwen with Issue Resolver behaved like a senior engineer who thought through the whole problem before touching the keyboard, evaluated his changes, tested the changes before shipping, shipped only when it was 101% sure.

What the Issue Resolver actually does

The idea is simple. Most AI agents are optimized to produce, eg. give them a prompt, they generate code. But for non-trivial issues, producing code immediately is often the wrong move. What you actually need first is understanding, scoping, and a plan.

The Issue Resolver skill, part of the Skillware open-source framework, enforces exactly that in a five-stage fashion:

Fetch the issue, comments, and linked PRs.
Understand the repository by reading its actual README, CONTRIBUTING guide, and directory tree at runtime — no hardcoded assumptions about what kind of project it is.
Analyze the problem, define what "done" looks like, map every file that needs to change, trace ripple effects into dependent modules, and rank up to three implementation options.
Present the plan and wait for your approval.
Implement but only after you say go, and only within the bounds of the approved plan.

The output is a structured resolution plan you can actually review. Affected files. Downstream risks. A recommended approach with rationale. It turns a chaotic "fix this issue" prompt into a disciplined, reviewable workflow that catches the tests, docs, and version bumps before they become "oh right, forgot that" moments.

Who this is for

If you're a developer, this is like having a teammate who does the legwork before the standup. You show up, they've already read the issue, explored the codebase, and handed you a breakdown of what needs to happen. You just make decisions.

If you're building AI agent workflows, it's a reusable planning scaffold. Instead of your agent raw-dogging every issue and hoping for the best, Issue Resolver gives it structure. The result is fewer iterations, fewer regressions, and output that reads like a human thought about it first.

Most importantly, it was made to work locally with local models, no cloud inference reliance or top shelf LLM credits. You can literally pair it with a 3B model and get better results than LLM darlings, not cause the model is "smarter" or whatever, but cause it knows exactly how to fetch issues, repos, how to parse them, how to make sure changes won't affect files out of scope, and if they do, it is aware and knows how to behave. Moreover, it will test, evaluate, and ensure everything is sound before shipping.

The bigger picture

What this experiment really drove home for me is that process matters more than model size. We spend so much time comparing benchmarks and parameter counts, but the gap between "seven back-and-forths with manual steering" and "one shot, PR-ready" wasn't closed by a bigger model. It was closed by a better workflow. The Issue Resolver skill is just a structured way of saying: slow down, think first, then act.

Please, feel free to contribute, it's 100% free and open source, and we are planning to enhance the skill with more features and pit stops for evals, eg. considering commit messages, parsing previous relevant issues and prs that are closed, and seamlessly managing git without assumptions or user input.

If you just want to try it yourself, the skill is available now at github.com/ARPAHLS/skillware or simply pip install skillware. Plug in a GitHub issue URL, optionally toss in your GITHUB_TOKEN and any project-specific instructions, and see how your favorite agent performs when it's forced to plan before it codes. I'd genuinely love to hear what happens. <3

DEV Community: Ross Peili

I Cancelled Five Project-Management Subs. Here's What Replaced Them.

The pain is familiar

What HPPM actually is

How it works (without the magic)

Who it is for

Try it

Agents Can Remove Image Backgrounds Locally — No Cloud API Required

Skillware in a nutshell

creative/bg_remover: what it does

Agent vs skill

Try it: install and direct execute

Try it: any agent loop

Why local matters for agents

Links

Skillware 0.4.3 — Gemini Tool Calling, CLI, Refined

Gemini adapter: from dict to types.Tool

Before — manual assembly in some setups

Now — one call, pass straight through

Automatic name sanitization

Examples, tests, and docs — aligned

Also in 0.4.3

Upgrade

Links

Any Agent Can Now Query Government Registry Data via NLP

Skillware in a nutshell

uk_companies_house_handler: what it does

Agent vs skill

Try it: direct execute

Try it: intent → officers pipeline

Try it: full Gemini loop

Outro

Quantum Is Less About Physics & Math, And More About You

The Only Quantum Supremacy That Matters Is Inside Your Head

Quantum Mechanics As A PsyOp

How LLMs Now Monitor and Cut Their Own Token Spend

What Skillware is in a nutshell

Meet the Token Limiter

How it works in a real loop

Architecture: Mind, Body, and a new category

Chain it with other skills

Conclusion

Any Agent or LLM Can Now Own A Wallet and Perform EVM TXs via NLP

Your agent can own a wallet now — natural language to on-chain swaps on Ethereum, Base, and other EVM chains.

Skillware in a nutshell

evm_tx_handler: architecture in plain terms

Agent vs skill (the split that keeps you sane)

Actions you actually call

Copy-paste: load the skill and run a Gemini loop

Safety rails (built into the skill, not bolted on later)

Limits (honest ones)

Where to go next

Skillware Crosses 8,000 OS Deployments and Goes Enterprise

The Transition to Enterprise Skillware

Initiating the Vanguard Cohort

Simulating Antiferromagnets with PennyLane: A Deep Dive into spinq-vqe

1. VQE and the Barren Plateau Problem in the Wild

2. Hybrid Quantum-Classical Material Screening

3. Entanglement Profiling

Get Started

[Boost]

Skillware Just Dropped a Skill That Lets Your Agent Solve Any GitHub Issue in One Prompt

Our OS AI skills framework is actually getting some heat - new contributors welcome <3

Skillware Just Dropped a Skill That Lets Your Agent Solve Any GitHub Issue in One Prompt

I Let Two AI Agents Fix the Same GitHub Issue, One Took 7 Tries, the Other Nailed It in One Shot

The setup

Claude Opus went first, and it did fine. Eventually.

Then Qwen 3.5 with Skillware had a go

What the Issue Resolver actually does

Who this is for

The bigger picture

`creative/bg_remover`: what it does

Gemini adapter: from dict to `types.Tool`

`uk_companies_house_handler`: what it does

Meet the `Token Limiter`

`evm_tx_handler`: architecture in plain terms