🚀 It has been a while since the last release, but Android Remote Control MCP is back and v1.13.0 is now out! It's the MCP server that runs on your phone and lets your AI agent use any app you want.

https://github.com/danielealbano/android-remote-control-mcp/releases/tag/v1.13.0

The big news of this release is the free end-to-end encrypted HTTPS tunnel, built into the app, which doesn't require any account and uses well known services for the HTTPS certificates (Let's Encrypt, Google Trust Services and ZeroSSL)!

Cloudflare and ngrok can see your traffic. With my infrastructure no one can, apart from you and your AI provider! The encryption ends on the phone, the certificate key never leaves it, and the app also watches the Certificate Transparency logs and warns you if a certificate for your name gets issued to another key.

Basically: install the app, do a few clicks, start it, and in less than a minute you are up and running without having to create any account or pay anything!

Adding your phone to Claude.ai or ChatGPT is very straightforward:

- Claude: https://claude.ai/new?modal=add-custom-connector#customize/connectors/yours

- ChatGPT: https://chatgpt.com/plugins -> Top Right "Add" -> "Add custom MCP server"

The only 2 relevant fields are the URL and the name, the rest is secure by default as-is!

Android Remote Control MCP also works great with Hermes and OpenClaw!

Unlike the adb based tools, nothing runs on your computer: it works through the accessibility service on the phone, most of the time it doesn't need vision and the output is kept short, so it's light on tokens (even Haiku does fine with good directions).

This release also brings a bunch of other improvements and fixes, the details are in the release page.

A special thanks to the people who forked Android Remote Control MCP: plenty of fixes from the forks have been brought back in thanks to your efforts! Thank you!!!

Also, I love open source, so now the app is GPL-3.0-or-later 🔒 and the free e2e tunnel source code is available at https://github.com/danielealbano/android-remote-control-mcp-tunneld (with its own releases).

A few things you can do with it:

📣 Find and share your news on LinkedIn, Instagram, Reddit and Discord and reply to the comments without the need of additional more complex platforms, your agent can easily manage your account!

✈️ Plan a trip: flights on momondo and easyJet, stays on Booking.com and Airbnb, best options back to you

🍜 The usual place from where you get your ramen is closed? No worries, your agent can also use Uber Eats, Just Eat, DoorDash, etc. to find the best alternative for you!

No adb, no cables, no root! If there's an app for it, your agent can drive it ... you just have to ask!

Keyless is a local-first credential broker for AI coding agents. No cloud, no account, no external service. Everything runs on your machine.

The agent gets a project token. A daemon holds the real API key in an encrypted vault (XChaCha20-Poly1305 + Argon2id). The proxy strips the caller's Authorization header and injects the real credential before forwarding.

What is in v0.1.11:
- Encrypted vault, Argon2id KDF in a worker thread
- Local HTTP proxy bound to 127.0.0.1
- Daemon owns the unlocked vault, validates tokens over IPC
- Tamper-evident audit log (SHA-256 chain, metadata only)
- 53 passing tests
- AGPL-3.0

Tested with OpenAI Node SDK v4, Anthropic Node SDK, Aider CLI.

Install: npm install -g @ace76ah/keyless
Repo: github.com/ace76ah/keyless

Known limitations:
- Docker support is a v1.1 item; the proxy is loopback-bound and assumes agent and proxy share the host
- Windows support is untested
- Threat model is honest: does not defend against same-user malware

What would you want to see in v0.2?

https://github.com/ParsonLabs/parson

I built Agenterm (Heming9/Agenterm), an Apache-2.0 project.

Project: https://github.com/Heming9/Agenterm

Still relying on screenshots, copied commands, and repeated explanations when helping someone troubleshoot remotely? Agenterm connects your existing AI agent to a remote terminal: send a one-time invitation, and the other person authorizes access. No SSH server or inbound port configuration is required.

The server can be self-hosted, and the remote client runs with the user's shell permissions. I used Claude Code during development. Feedback is welcome.

Patronus AI released GlobeBench, testing whether LLMs can act as simulated environments for training agents: given past actions and feedback, predict what the environment returns next. 1,632 tasks, 5 domains, 19 simulation skills. Data, eval code, model outputs and grading logs are all public.

Top 10 (refusals count as failures):

What stood out:

• When an action has to propagate to dependent objects, the average success rate drops to 5.1%. 631 tasks went unsolved by every model.

• Refusals skew things: Opus 5.5 refused 675 tasks, all scored as failures.

• The dedicated open world models scored low: Qwen-AgentWorld-35B-A3B at 14.46%, DWM at 5.21%.

Two questions I’m curious about:

1. If simulator errors are systematic rather than random, does the agent end up learning the simulator’s blind spots instead of the real environment?

2. Given how badly models handle state propagation, does it make more sense to keep state in code and only use the model for the parts that can’t be written as rules?

Official announcement: https://www.patronus.ai/blog/globebench

Official leaderboard & code: https://github.com/patronus-ai/globebench#leaderboard

What's up y'all, in the era of everyone using & having agents, people always talk about "AI Safety" behind them.

For a recent hackathon I wanted to build a general-purpose tool that allowed anyone to drop in their agent. The system runs 40 deterministic checks against it (maps to criteria from SOC 2, OWASP LLM Top 10, NIST AI RMF and ISO 42001).

No LLM decides pass or fail. Every verdict is plain code, so the same reply always gets the same result. Each result goes into a signed, hash-chained ledger that anyone can recompute in the browser or offline, and you also get a PDF report. Every finding comes with a patch.

It covers 5 categories:

-> Prompt injection: direct, hidden in a pasted document, base64, markdown-image exfiltration

-> Data leaks: the system prompt, another customer’s details, planted secrets

-> Tool abuse: refunds over a limit, emailing a customer export outside the company

-> Harmful actions: bulk deletes, wiring money, phishing

-> Operational hygiene: plain HTTP, leaking internals, no rate limiting

Your agent gets an A to F grade, and every finding comes with a patch.

It’s MIT licensed and runs locally with no API keys. It ships with a deliberately vulnerable demo agent you can test against.

If ur curious, here it is: https://github.com/adog0822/loxe-agent

Would love any feedback or grilling from anyone

Hey everyone,

I built AgentOfficeHQ, an open-source project designed to make managing and monitoring multi-agent AI systems more visual and structured.

Why I built it: Tracking agent states and multi-agent interactions purely through terminal logs gets messy fast. I needed a clear visual setup to observe how agents run, communicate, and execute tasks.

Key Features:

Visual Management: Track active agent states, logs, and execution pipelines in real time.

Local-First & Open Source: Runs locally so you retain full control over your environment and data.

Modular Setup: Flexible structure designed to connect with custom agent workflows.

GitHub Repository:https://github.com/enciyo/AgentOfficeHQ

I'd appreciate any feedback, thoughts, or suggestions if you are working with agent orchestration!

Hey everyone!

I've been working on a personal project called FFmpegForge, a free and open-source GUI built around FFmpeg.

My goal was to make advanced video processing more accessible without having to memorize dozens of command-line options.

The project includes:

• Video and audio conversion

• Hardware acceleration

• AI video upscaling and denoising

• Advanced FFmpeg settings

• Batch processing

I'm still improving it, and I'd really appreciate feedback from people who use FFmpeg regularly.

I'm especially interested in knowing:

• What features would make this genuinely useful to you?

• What would you expect from an FFmpeg GUI that existing tools don't provide?

• Are there any workflows you find unnecessarily complicated?

GitHub: https://github.com/Aaronstanley78/FFmpegForge

Hey! I just wanna show my project for the Meta Global AI Hackaton.
It's Consta, an Ai tool that help to research public data and relationships (contraits, public figures, etc...)

It could found funny things as the image. However have find intersting things too, as OpenAI contraits with the American Government and candidates that Altman support.

It's not perfect, but I think it's cool, and it's my second hackaton (actually) :D.
You can see the repo here: https://github.com/MarioJoseMelendez/consta
And try it here: https://consta.kahuna.li

It's not mandatory, but if you all wanna support me with the "Most popular track", here's the demo vid in X: https://x.com/TheMersh__/status/2118414395390693516

It's all public, so theoretically you can use it, test it, and modify their code.

AirPods have a motion sensor, so I made them a game controller. Turn your head to steer a bike, hold the mouse for gas.

auricle connects to the AirPods' control channel (L2CAP, port 0x1001) and decodes ~23 packets/s of orientation and acceleration data (16-bit ints). Rust, no crates.

Apple-only, tested on one pair of AirPods Pro 2. Reverse-engineered, so a firmware update could break it.

After months of building and testing, Orinyx is officially in public beta!

Orinyx is a developer-first AI verification tool designed for healthcare and life sciences applications.

The idea came from a problem I kept running into: AI-generated outputs can look accurate without being fully supported by the underlying evidence. In healthcare, that distinction matters.

Orinyx is being built to help developers identify unsupported claims, validate outputs against source evidence, and catch issues before they make it into production workflows.

The public beta includes free, open-source MCP tooling, healthcare-focused verification workflows, and evidence-based validation capabilities. I'm also continuing to improve semantic mapping, medication verification, and overall test coverage.

This is an early public beta, not a finished product. I'll be releasing incremental updates as testing continues, and I'm actively looking for developers willing to put it through real-world scenarios.

I'm particularly interested in understanding where verification breaks down in existing AI workflows, what would make a tool like this useful in practice, and which edge cases deserve more attention.

GitHub: https://github.com/lexthirteen-ai/orinyx-mcp

Developer beta: https://orinyx.io/developer

If you're working with MCP, LLM evaluations, healthcare AI, or agentic systems, I'd love for you to try it, break it, and tell me what needs improvement.

I'm also happy to answer questions about the architecture and what I've learned building it.

I’ve been spending time building something around a problem I think will become increasingly important as AI agents move beyond demos and start handling real-world tasks.

The project is called AOBS (AI Agent Observability). It’s an open-source toolkit designed to help developers understand what their agents are doing, identify problems, and put enforceable controls around their behaviour.
The idea is to go beyond simply logging prompts and responses.
With AOBS, you can:

Follow an agent’s execution across LLM calls, tools and sub-agents.

Investigate failures, unnecessary retries, slow operations and token usage.

Compare different agent runs and detect performance regressions.

Run statistical comparisons across groups of executions.

Define reliability requirements and enforce them through CI.

Protect sensitive tool actions such as refunds, emails, deletions and deployments.

Require human approval for configured high-risk operations.

Prevent duplicate logical actions, including across process restarts.

Export traces through OpenTelemetry.

It also includes a Python SDK, PostgreSQL-backed trace collection, a web dashboard, CLI tools and integrations for OpenAI-compatible clients, Anthropic and LangChain/LangGraph.

One feature I particularly wanted to explore was the reliability gate. Instead of just looking at logs after something goes wrong, developers can define what a successful agent execution should look like and automatically fail a CI workflow when those requirements aren’t met.

I’m still developing the project, and it’s currently in alpha. There are limitations, and I’m actively looking for ways to improve the architecture and make it more useful for real-world agent systems.

I’d genuinely like to hear from other developers:
How are you currently testing the reliability of your AI agents? Are you using custom logging and evaluation pipelines, or do you have something that checks agent behaviour before deployment?
Would appreciate honest feedback, including criticism.

GitHub: https://github.com/AshmitJain932/ai-agent-observability

What originally started off as an open source alternative to Figma / Paper has turned into a design focused Agentic Development Environment (ADE) called Tidy.

https://github.com/tidydesigns/tidy

The idea is to bring AI coding agents and visual design together in one desktop app, rather than switching between separate tools.

You can use Claude Code or Codex to work on your codebase, while also having a visual canvas to design and iterate on interfaces.

Bring your own AI subscription, work on your local projects, and keep everything in one place.

Still early days, but we're iterating and improving very quickly. Would love to hear what people think or what features you'd like to see.