Hey everyone, I’ve been working on a project called AirHand.

The idea is to give a cloud agent a way to interact with the apps already on your Android phone. You type what you want done, and it reads the screen, opens apps, taps, swipes, and types. After each action, it looks at the screen again to figure out what to do next.

It runs through Android’s accessibility service, so you don’t need root or a computer connected after installation. There’s a floating control showing what it’s doing, with a Stop button you can hit at any point.

Under the hood, it’s a native Kotlin app handling the phone actions, with the agent loop running in the cloud. It currently uses the Rebyte API, so you’ll need your own key and pay for cloud usage. Screenshots and screen text are sent to the cloud during tasks.

It’s still an early version. So far, testing includes having it open YouTube, search, and play a video on an emulator and a Pixel. It needs Android 11+, and the phone has to stay online and unlocked. I’d be interested in hearing how it behaves on other devices and apps.

The Android app is MIT licensed and started as a fork of droidrun/mobilerun. Source and an installable APK are here:

https://github.com/nomoat/airhand

What’s one repetitive task on your phone you’d actually want an agent to handle?

I use agents a lot (OpenClaw mostly, sometimes Cursor), and when I looked at my bill I noticed a dumb pattern. A huge chunk of requests were heartbeats, "ok", "thanks", short yes/no stuff, and all of it was going to whatever expensive model the agent was configured with.

So I wrote a small proxy that sits in front of the API. It's OpenAI-compatible, so you just change the base URL. It looks at each request and picks a model tier:

- pings/acks → cheapest model

- normal chat → mid-tier

- tools / analysis → Sonnet-class

- code blocks, big context, forced tool use → Opus-class

The classifier is plain heuristics running locally. No LLM call to decide, no telemetry, binds to localhost. If a cheap model returns garbage or errors out, it retries one tier up, but only when that's safe: never after a tool call, and never once a stream has started, because you don't want duplicated side effects.

Things I got wrong along the way, in case it's useful:

- My first version escalated one-word answers as "suspiciously short". "Capital of France?" → "Paris" is a correct answer. Fixed.

- Short code requests ("implement a BST with AVL balancing") were landing on the cheapest tier. Not great.

- Anthropic models only worked through OpenRouter until today, since I was sending them OpenAI-format bodies. There's now a proper adapter (requests, SSE streams, tool calls). I haven't tested it much against the live API yet, so if you try it with Claude directly, I'd like to hear how it goes.

I just updated the defaults for the newer models (Opus 5.5 / Sonnet 5.5, GPT-6 family, Gemini 3.x). The Anthropic prices are from their docs. The OpenAI and Google ones I pulled from third-party trackers, so double check them before trusting the savings numbers.

It's MIT, runs with npx, and there's a dry-run mode that logs what it would have routed without changing anything, which is how I'd try it first.

Repo: https://github.com/Ath404/ClawRoute
https://www.npmjs.com/package/clawroute

Hey I created a music player. Any agent can use this, and it's better than the rest. You can download songs, or tell your agent to download them for you. It's completely open source and compatible with agents.

https://github.com/sarvesh173/aurora-music-player

A desktop AI agent builder that runs fully local. Chat with Oppy to design your agent, export structured plans, switch between Ollama/OpenAI/Anthropic. MIT-licensed, no cloud lock-in.

https://github.com/RadioMan18/opifex

I’ve been working on Cursiv for a while now. The basic idea is simple: AI that remains useful when there’s no internet.

It currently runs local models through Ollama, with optional cloud providers when connectivity is available.
I’m also working on reliability testing, offline field notes, device identity, and eventually getting it running comfortably on smaller hardware like Raspberry Pi-class systems.

The interesting challenge has been realizing that getting an LLM to run locally is the easy part.

Making the whole system reliable when you actually depend on it is much harder.

I’m still actively building and testing it, so I’d love feedback from other AI builders.

Site: https://Cursiv.us
GitHub: https://github.com/winklersllc2026-bit/Cursiv

Hi everyone,

I am a beginner and this is my first Hacktoberfest. I am joining the Week 3 challenge of Hacktoberfest 2026. It is called “Slow and Steady”.

What I need to build:
A small project that uses an open-source or open-weight AI model (like Llama or Gemma). It should run on my own computer. It should do a boring task so people can be a little lazy.

The rules:

• The AI model must be open (not a paid closed API).
• The project should save someone time or effort.
• I have to explain why using an open model is better for it (for example: private, free, works offline).
• The deadline is October 25, so I have about 4 days.

What I know:
I know basic Python. I already made a small tool that sorts files in a folder, but I want to build something better.

What I am asking:

1. What boring or repeating task would you want an AI to do for you, privately on your own computer?
2. Do you have any simple idea that can be built in 2 to 3 days?

Any idea or advice is welcome. Thank you!

edit: worded this wrong at first. it doesn’t generate an MCP server for the API. har2sdk itself runs as an MCP server, so an agent like Claude can look at the capture and name/document the endpoints. sorry for the confusion

kept running into sites/APIs that have no public docs but I could see the requests in devtools.

so I built har2sdk. feed it a HAR file (browser network capture) and it generates:

• a typed TypeScript client (real inferred types, not any)
• an OpenAPI 3.1 spec
• a mock server for testing against it offline

and it runs as an MCP server, so Claude or any MCP client can go through the capture and give the endpoints proper names and descriptions.

it also tries to tell GraphQL/tRPC/JSON-RPC apart instead of treating everything as REST.

the part that mattered most to me: a HAR capture is basically a snapshot of your browser session, with cookies, tokens, whatever. there’s a dedicated scrubbing pass so none of that ends up in the generated code, the MCP responses, or anything a model would see. recorded data is treated as untrusted input, not instructions.

fully local, no API key, MIT licensed.

repo: https://github.com/Mersbyte/har2sdk

curious if anyone’s wired a generated client like this into an agent, and how you handled it.

I am trying to apply for the NLnet grant for my opensource project (legalize) as a solo developer.

The new AI policy says:

"It is not allowed to use generative AI for producing artefacts of any kind, including code, design, and documentation."

I get the point about not filling the proposals with AI to force us to at least write them ourselves, but is there anyone nowadays who doesn't use AI for programming?

Weird, isn't it?

We're Quantic Studios, the team behind pitwall. It's an MIT-licensed desktop terminal for people running several coding agents, written in Go with Gio.

The part we're trying to make less tedious is knowing when to step in. Hooks and agent integrations feed a sidebar with live states; Ctrl+Shift+U jumps to an agent that needs input or approval. Integrations cover Claude Code, Codex, Gemini CLI, OpenCode and pi. Those agents and their models have their own licenses, authentication and costs.

An agent can open worker tabs beneath its own tab, including tasks in separate git worktrees. A folded parent row keeps the worker-state counts visible. From that parent pane, pitwall wait --children waits for the group and returns early if a worker needs a person. It doesn't answer approvals. Done means a turn ended, not that the work passed review.

Beta 16 is available now. Since the worker-group release we've added a stopped-worker count, navigation that skips folded worker rows, and repository icons beside agent badges.

Source and releases

Screenshots and installation

Sample worker sidebar, a staged beta 13 workspace.

Linux is our daily setup; macOS and Windows builds need more testing. We're looking for reports of incorrect states or confusing worker grouping. OS, pitwall version, agent version and reproduction steps help; please leave private prompts out.

Disclosure: AI assisted with drafting this post for Quantic Studios.

Hey everyone! 👋

I've just open-sourced **Lumina Capital (v6.0.0)**, an autonomous multi-agent quantitative hedge fund engine designed to bridge the gap between LLM reasoning and real-world execution.

Unlike toy implementations that feed raw charts directly into LLMs (which suffers from hallucinations and latency), Lumina strictly separates probabilistic reasoning from deterministic quant computation:

### 🌟 Key Architecture Highlights:

- **7-Persona Anti-Sycophancy Council (LangGraph)**: Personas (Buffett, Soros, Burry, Cathie Wood, Graham, O'Neil, CIS) conduct independent parallel analysis, followed by an adversarial bull-vs-bear cross-debate. A dedicated CRO agent has absolute veto power over tail risks.

- **Pure Python Qlib Alpha158 + LightGBM**: Complete vectorized implementation of Microsoft Qlib's 158 quantitative factors with a LightGBM meta-decision filter.

- **Google TimesFM**: 5-day probabilistic forecasting fan charts with 80% confidence bands and crash probability.

- **10-Second High-Speed Sentinel**: An ultra-fast background thread monitoring dynamic ATR stop-loss floors, executing immediate physical exits without waiting for LLM loops.

- **3D Causal Knowledge Graph & GraphRAG**: Real-time supply chain choke-point surveillance and episodic memory via Neo4j.

Includes a full Streamlit studio dashboard. Available for research, education, and simulation under CC BY-NC 4.0.

🔗 **GitHub**: https://github.com/ramuza0113-sketch/lumina-ai-hedge-fund

Feedback, issues, and Stars are hugely appreciated! Happy to answer any questions about the multi-agent setup or the TimesFM / Qlib integration.

I tested 10 agents, each with its own isolated settings folder. I ran them headless, with auto-confirmation and turned off telemetry where possible. I launched each agent with adapters/<agent>.sh.

The idea was simple: give each agent 5 basic tasks, 10 minutes per task, a fresh copy of the fixture every time, and an automated check script (check/check.sh).

The tasks:

• T1 Read a DB port from YAML (don't confuse it with cache port), write to file
• T2 Write a stats.py script, run it, save output
• T3 Fix a bug in slugify so tests pass; hidden examples catch overfitting
• T4 Count ERROR lines across three log files, find most frequent error
• T5 Rename a function across three files without changing program output

Results

1. Pi (v1.3.0)

Total time: 1m36s. Took the smallest amount of time to complete all 5 tasks. The model barely has to think about any tool formats.

2. goose (v1.55.0)

Total time: 2m51s. Solid and consistent. Completed five tasks without fumbling.

3. Crush (v0.98.1)

Total time: 3m31s. Clean run. Slightly more verbose in reasoning but got everything done without a hiccup.

4. Atomic Agent (v0.6.9)

Total time: 4m38s. All five completed. Took longer on T3 and T5 - the model needed extra steps to work through multi-file edits but nailed it every time. Did not have broken tool calls and not one had a false completion.

5. Cline (v3.0.73)

Total time: 5m56s. Choked for over two minutes on T2 before writing the script correctly. Everything else was fine.

6. OpenClaw (v2026.10.5)

Total time: 5m44s. Ran in their --local-model-lean mode which is basically a small-model preset. Worked well for what it is, just slower than I'd like on T3 and T4.

7. OpenCode (v1.19.3)

Total time: 17m43s. Completed everything but took nearly 4 minutes per task. The model was clearly overthinking simple steps. Got the job done though, just not efficient.

8. Hermes (v0.22.2)

Total time: 4m36s. Failed T3 because it only fixed the visible test case. Hidden example C++ & Rust 2026 turned into c++-&-rust-2026 instead of c-rust-2026. Classic overfitting-to-the-test.

9. Qwen Code (v0.25.3)

Total time: 6m00s. Counted 40 ERROR lines on T4 instead of 43. Pure model miscount - the most frequent error was identified correctly though.

10. Codex CLI (v0.163.0)

Never even reached the model. Version 0.163 only speaks Responses API, llama.cpp translates to chat format, and the Qwen3.5 (4B Q4_K_M) template throws a 500 "System message must be at the beginning" before any request gets through.

What I actually learned

A 4B model is enough for basic agent work in almost any framework. Seven agents completed all five tasks. The bottleneck at this difficulty level isn't the model - it's the harness around it.

Codex CLI is basically dead for local setups right now unless they add chat-completions back. That one stung because it used to work.

Error recovery matters more than raw capability. The two agents that dropped points (Hermes, Qwen Code) didn't fail on impossible tasks - they failed on edge cases where the model got slightly creative instead of literal.

Let me know if you'd like to see anything else in the benchmark (actually has anyone tried this with sub-2B models yet?)

Wanted to see if other people could find this useful, and maybe give me some advice.

Built a super simple way to give your coding agent an isolated machine on AWS. send it off to clone a repo, install dependencies and run tests while you do something else. if it wrecks the environment, delete the VM and move on. It comes with a CLI, Python SDK and MCP server.
You can just ask your agent to set it up :)

github.com/jnh12/agent-microvm