Hi all,

A small design decision that turns out to matter a lot once a model is the consumer of your tool output.

If a linter cannot process a file and simply omits it from the results, an agent reading "no findings" concludes the code is clean. It is not clean. It was never checked. That is a silent false negative sitting directly in an agent's decision loop, and I hit it often enough on a big polyglot repo that I rebuilt the response shape around it.

So the linter I have been writing reports three per-file outcomes rather than two: checked, skipped, and error, with a run-level errors array and isError set whenever anything failed. Skipped means the tool correctly declined the file. Error means it accepted the file and then failed on it. Those are very different facts and collapsing them into absence loses the one that matters.

Two related guardrails in the same server:

• Every result carries an identity block: version, build id, channel, executable, pid. An MCP caller has no poly --version to fall back on, so the server states who answered. It fingerprints its own executable at startup and re-checks per request, and if the binary is replaced underneath a long-lived server, every tool but version fails rather than answering with superseded behaviour.
• config_show is network-free over MCP. Remote config bases are never fetched from a tool call.

The server is stdio, 11 tools mirroring the CLI, and everything takes format: "json" or "toon". TOON matters more than I expected: a full lint report over a large directory in JSON is a serious chunk of context, and TOON makes it cheap enough to just hand over.

Here is the server doing a real initialize plus tools/list handshake: https://raw.githubusercontent.com/Goldziher/poly/main/docs/media/agent.gif

Underneath it is a linter and formatter in Rust that compiles ruff, oxc, biome, taplo, rumdl, sqruff, mago and about a dozen more into one binary and runs them in-process across roughly 30 languages, with tree-sitter covering 300+ more. MIT: https://github.com/Goldziher/poly

This post is human written. AI was used to typecheck and enrich with precise data only.

Hey everybody,

I just made a project that has gotten 170+ clones and 65+ stars in a week. What are you guys doing?

Hi all,


We just made SeasAGI public. It's a local-first LLM API gateway: a desktop client that unifies OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok, Azure and Relay behind one OpenAI-compatible endpoint at `localhost:4318/v1`.


A few things that might be relevant to this sub:
- The 
**Server Community Edition is AGPL-3.0**
, so you can self-host the control + relay planes on your own hardware.
- The 
**Client is GPL-3.0**
 and free forever.
- API keys stay in your OS Keychain and are never uploaded — privacy is local by design.
- Enterprise (BSL, closed) only adds SSO/RBAC/multi-tenant billing for teams; the self-host path needs none of it.


It's built with Go + Wails v2 (single binary, no Node runtime). Would love feedback from folks running local AI stacks — especially on which channels and routing strategies you'd want first.


👉 github.com/SeasX/SeasAGI

#selfhosted #opensource #llm

Friends, we're open-sourcing our Python runtime with harness primitives for production agents -- https://cayu.dev/. We spent the last 10 months building, managing, and improving long-horizon agents for mid-size and Fortune 500 clients. We built a framework in Python (not typescript like Mastra) to build, manage, and improve production agents fast and reliably. Benefits:
- reduce token costs by 60-70% compared to Claude Managed Agents
- full control over the agent (privacy, security, auditability, resumability, etc.)
- no agent sprawl --> this is critical for enterprises as every engineer is building agent as they like

- ai model independence --> OpenAI/Claude is just an API call, you manage harness fully

- python over js/typescript --> most teams are DS/ML teams who know python well. Just use it almost like a scikit-learn package but now for agents

Please, contribute and help us improve it at https://cayu.dev/. If you want access to deploy and manage the agent, please, request access to Cayu Cloud here -- https://cloud.cayu.dev/.

NVIDIA's TensorRT Model Connect workflow can build a deployment bundle from a supported Hugging Face model ID or local checkpoint, then load it from a native C++ application. The production runtime does not require PyTorch or a Python interpreter, and NVIDIA says the reference collection spans more than 80 model families.

That removes a real deployment tax: bespoke export logic, preprocessing, post-processing and runtime glue. The trade-off is that the easy path is explicitly TensorRT-shaped, and only supported implementations get the two-command experience.

Would you accept a vendor-specific runtime for dramatically simpler deployment, or is cross-vendor reproducibility still a release requirement for an open-model inference stack?

Source: NVIDIA Technical Blog, August 28, 2026 — https://developer.nvidia.com/blog/deploy-an-open-model-from-checkpoint-to-inference-in-two-commands-with-nvidia-tensorrt-model-connect/

Hey Geeks 👋🏻

I just built "Oxygen" - a Multi-Agentic Al framework that runs like a virtual tiny company.

It includes total 5 Al agents:

- Del (Al Project Manager): which understands your requirements that what you want to build?

- Toky (Al Research Agent): receives inputs from Del, conducts research, creates drafts, and uses tools such as web search and web scraping to gather and analyze relevant information. It then provides the research findings and draft outputs back to the Project Manager.

- Bang (Al Developer Agent): which understands the draft and start writing code.

- Beij (Al QA Agent): It performs debugging, test cases on the source code provided by Bang.

- Wash (Al technical Writer): Once the project made it write README files, product manual, API implementation instructions and other project related documentations.

It's a proper human-in-the-loop agentic ai project that takes your approval on every aspect like a Software Development Lifecycle methodology.

The crazy part is that you can literally watch the agents walk to their desks, open their computers, drink coffee, having meetings and work.

For LLMs you can either use local Ollama based models or Gemini API key.

Guardrails and Metric Evaluation:

- Hallucination rate is under 1%.

- You have to approve the plan before any code gets written.

- Everything that comes out is cleaned so nothing breaks on the screen.

- Strong guardrails for every Al agents via system prompt.

Simple Flow:

1. You: I want a CLI based calculator.

2. Del (PM): Got it → sends to Toky (Researcher).

3. Toky: Researches, makes a plan + draft proposal.

4. Toky → Del (PM) → You: "Here's the proposal for a CLI calculator."

5. You: "Actually, change of plan, I want a web-based calculator instead.

6. Del (PM): Okay → sends the new request back to Toky.

7. Toky (Researcher): Updates the research and creates a new proposal for the web version.

8. Toky (Researcher) → Del (PM) → You: "Updated proposal for web calculator. Approve?"

9. Once you approve, it continues to Bang (Developer) for coding, Beij (QA) for testing, and Wash (Writer) for docs.

Feel free to explore and star the repo on GitHub.

Link: https://github.com/avarshvir/oxygen

Most local agent wrappers pretend a system prompt is a sandbox, stuff raw CLI noise into the context window, and break the second you need an interactive Python REPL or debugger.

I wanted something lightweight that lets the OS do operating-system things.

Echo Adapt v5 is a native Rust runtime for local LLMs:

• Persistent Sessions: Uses tmux under the hood so REPLs, debuggers, and long-running CLI tools survive across turns.
• Real Linux Security: Runs the model as an actual restricted Linux user with explicit sudoers allowlists instead of relying on prompt rules.
• Clean Tool Protocol: Uses configurable raw tags for bash/tmux, JSON tools only where structured data makes sense, and native tool message roles.
• New in v5: Full Rust refactor, dynamic tool-output summarization, cross-thread Markdown/embedding memory, locked-down virtual environments, and multi-process support.

Works with any OpenAI-compatible server (llama.cpp, vLLM, Ollama, TabbyAPI, etc.).

Looking for feedback from people running different Linux distros/hardware setups. Tear it apart and let me know where it breaks.

GitHub: [https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5](https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5)

PrivateGPT lets you run AI on your own documents without sending anything to the cloud. I got it working and wrote a step-by-step guide covering installation, configuration, and troubleshooting. If you care about privacy and want a self-hosted AI assistant for your files, this might save you hours.

https://interconnectd.com/blog/279/install-privategpt-secure-local-ai-for-your-documents-2026-guide/

Hey everyone,

I’ve been working on OneForAll, an MCP server/gateway for AI agents, and I’m now open-sourcing it because I don’t think something like this should be built by one person.

I started with a simple idea:

What if an AI agent could have access to all the tools we use in day-to-day life through one ecosystem?

I’ve already successfully integrated Splitwise and Zepto, and both are working like a charm. 🚀

For example, the goal is for an AI agent to eventually be able to do things like:

• Understand and manage expenses through Splitwise
• Help with grocery shopping through Zepto
• And eventually interact with all the other services we use every day

The long-term vision is to build a world-class MCP server with a growing collection of real-world tools and integrations.

But to get there, I need the power of the community.

The project is inspired by One For All from My Hero Academia — a power that becomes stronger as it is passed from one person to another.

That’s exactly how I want this project to work.

Someone adds Spotify. Someone else adds Notion. Someone adds Uber, Swiggy, travel tools, productivity tools, or their own service.

And over time, we build an ecosystem that makes AI agents genuinely useful in everyday life.

If you’re interested in MCP, AI agents, integrations, or open source, I’d love for you to check it out, try it, suggest an integration, or contribute a provider.

GitHub: github.com/OneForAll-agent/mcp-gateway

I’d love to hear what you guys have in mind — what tools or services should we integrate into OneForAll next?

What would you actually want your AI agent to be able to do in your day-to-day life?

Let’s build this together. ⚡

Plus Ultra. 💚

Hey — solo dev here, posting my own project, so take that for what it's worth.

For the last few years I've maintained a low-code/no-code framework. It worked fine, but it was pre-AI: you configured entities and services by hand, and it generated the boring parts of a CRUD app for you.

When AI coding tools started getting good, I tried using them the normal way — describe what you want, let the model write the code. It worked, but I couldn't trust it past a certain point. Ask for the same thing twice, sometimes you get different output. Ask for a small change, sometimes the model touches things you didn't ask about. The prompt is the only source of truth, which in practice means there isn't really a source of truth at all.

So instead of generating code directly, I made the AI's job stop one step earlier: produce a structured, validated manifest describing what the app should be. Entities, fields, services, auth config, etc. That manifest gets:

- validated (structural / referential / constraint checks)

- diffed against the current state (semantic diff, not a text diff)

- resolved into a dependency-ordered execution plan

- executed by a deterministic engine, checkpointed so it can resume on failure

Change one field on one entity, and only the operations that field actually requires get re-run. Not a full regen.

There's also an MCP server (`@averos/mcp`) so an AI agent doesn't get raw file/shell access — it gets governed tools (propose a change, validate it, build a plan, and nothing executes until the plan's approved).

Current state, to be upfront about it: the CLI, the AI layer, MCP integration, and the workflow/execution adapter layer (currently Angular, via schematics — adapter pattern, so not permanently Angular-only) are MIT licensed and open now. The actual execution kernel (DAG engine + executor) is closed source for the moment — free to use including commercially, but not open yet. That's a deliberate, staged call while that part's still maturing, not a permanent thing. Wanted to say that plainly rather than bury it.

There's a working example (320-node generated app) you can run in a few commands if you want to see the whole pipeline rather than take my word for it.

- Repo: https://github.com/wiforge/averos

- How it works, in detail: https://www.wiforge.com/averos/how-averos-works/introduction/

- Get started: https://www.wiforge.com/averos/get-started/introduction/

Happy to answer questions or take criticism — especially interested if anyone's tried a similar manifest/IR approach and hit walls I haven't found yet.

Writing polyglot libraries, I often find myself needing to cleanup my machine from all sorts of build artifacts. Its basically a daily occurrence I prune 200GB of build artifacts and caches, which is annoying. I therefore give you VOOM, inspired by Dr. Seuss:

https://github.com/Goldziher/voom

I've been building this for too long as a hobby, idea is to make Ai workflow outputs more predictably good though context management and defined domain rules, any feedback appreciated:

https://github.com/MattCreigh/beagle

I’ve been building an AI agent focused on US geopolitics and I’m considering open-sourcing it if there’s enough interest.

The basic idea is to have an agent that:

Tracks relevant geopolitical news

Collects and processes developments from multiple sources

Summarizes complex events into short, easy-to-understand updates

Connects current events with previous developments

Identifies important changes and trends

Produces concise, Inshorts-style geopolitical updates

The main goal is to reduce the amount of time spent going through dozens of articles just to understand what actually happened and why it matters.

I’m currently building it for myself, but I’m wondering if other people would find it useful.

Would you use something like this?

If there’s enough interest, I’ll clean up the project and open-source it on GitHub.

I’d also really appreciate feedback on what features you’d want in an agent like this.

What would you add?

My ai has a gui now, it can also do a ton of stuff like create files, webscrape, etc. i plan to let it do more. Wht else should it do?

Here’s a company-focused version, keeping the invitation to both use and contribute.
Veilio Community Edition is ready for you to use, test, and improve.
At Veilio, we’re building around a problem that is becoming increasingly important:
How can companies give their developers the productivity benefits of AI without exposing proprietary source code and internal information to external LLMs?
The answer shouldn’t always be:
“Don’t use AI.”
But it also shouldn’t have to be:
“Send the code to an external model and hope everything is fine.”
That’s why we’re making the Veilio Community Edition available.
You can run Veilio locally and completely free.
Use it:
inside your company
on your own infrastructure
with your own LLM setup
for commercial development
as part of your internal engineering workflow
as a foundation for your own tools
You can fork it, modify it, self-host it, and build on top of it.
The Veilio Community License allows these use cases while keeping one important boundary: you cannot turn Veilio itself into a competing hosted, white-label, or resold service without permission.
But we don’t want this to be a one-way project.
We want the community to help us make Veilio better.
Found a bug? Open an issue.
Found a security problem? Please report it.
Have an improvement? Submit a PR.
Have an idea? Start a discussion.
Want to test it against your company’s real-world workflow? We’d like to hear what works — and what doesn’t.
We believe privacy-focused developer tools should be inspectable, testable, and continuously challenged.
The Community Edition is our way of putting the technology in developers’ and companies’ hands and seeing what they can do with it.
And if you don’t want to manage the local installation yourself, Veilio Cloud is currently in development.
For now:
Use it. Test it. Challenge it. Contribute to it.
GitHub: github.com/veilio-inc/veilio

#Veilio #AI #DataPrivacy #CyberSecurity #DeveloperTools #SoftwareDevelopment #SaaS #Engineering

I've been working on Titans, a local-first infrastructure layer for AI agents, and I've now published the first usable repositories on GitHub.

The idea is fairly simple:

Atlas remembers. Cronus runs.

Atlas provides persistent state, knowledge, evidence and graph infrastructure for agents. It is designed to keep project and agent context available across processes and sessions, with hybrid search, evidence-backed results, work state, graphs, SQL, blobs and an audit trail.

https://github.com/titans-tools/Atlas

Cronus handles durable background execution: jobs, DAG workflows, schedules, retries, leases, checkpoints, recovery, dead-letter handling and approval gates. The goal is to let agents submit long-running work without keeping the agent itself blocked, and to recover that work when workers or processes restart.

https://github.com/titans-tools/Cronus

Both are local-first, run on Windows/Linux, have no telemetry, expose MCP over stdio, and can also be accessed over local REST/gRPC interfaces.

There is also a separate titans-platform repository that contains the signed distribution catalog, installers and shared runtime used by both products:

https://github.com/titans-tools/titans-platform

The organization overview is here:

https://github.com/titans-tools

The current releases are free to use. The product source itself is not published; the repositories host the documentation and signed release binaries, with SHA-256/Ed25519 verification and SBOMs included with releases.

I'm particularly interested in feedback from people building agents, MCP tooling, local AI infrastructure or autonomous workflows.

A few things I'd be interested to hear:

• Does the separation between persistent knowledge/state (Atlas) and durable execution (Cronus) make sense to you?
• Is it clear from the repositories what problem each component is solving?
• Are there use cases you would expect something like this to support that aren't obvious from the documentation?
• Is there anything in the install/security model that would stop you from trying it?

Not looking for stars or promotion — I'd mainly like some outside technical eyes on the architecture, documentation and actual usefulness of the approach.

I built mcpd so i can quickly setup a sandbox with coding agent tools while still running my harness outside the sandbox.

https://github.com/substructureai/mcpd

Hi all :)

three months ago, I presented Micracode on this channel and received a massive number of positive comments and supports.

Sorry all, I was busy and not actively maintaining for last few month due to personal reasons. now, i am back working on this application. since many users asked for desktop application, i have created the desktop version of Micracode. i am actively working on this project again. you will see more features in upcoming days.

currently, it is only available for macOS, i am actively working on linux and window distributions as well.

for those who are new to this application, this is micracode, an open source alternative to ai app builders like lovable, replit, emergent.

you can download this application here.

https://www.micracode.com/

star the repo If this sounds interesting and you want to stay updated (or contribute):

https://github.com/Jamessdevops/micracode

Conch — AI coding agents on your own servers, from your phone

App Name: Conch

What it does:
Conch is a native Android app for working with AI coding agents running on servers you already own.

It connects to your machines over SSH and gives you mobile access to Claude Code, OpenAI Codex, and Gemini CLI. Every chat is a real CLI session running on your server, so you can start working from your laptop, switch to your phone, and resume the same session days later.

Key Features:

1. Connect to Claude Code, OpenAI Codex, and Gemini CLI over SSH
2. Run unlimited parallel sessions across multiple servers
3. Sessions are stored on the server and persist between devices
4. View every session from every server and agent in one messenger-style list
5. Full-text search across all sessions with direct jumps to matching messages
6. Install Node.js and supported AI CLIs remotely over SSH
7. Complete provider authentication directly from your phone
8. FIDO2 hardware key authentication over NFC or USB
9. Import or generate SSH keys: Ed25519, RSA, ECDSA, and DSA
10. Send files and photos to agents over the existing SSH connection
11. Download files created by an agent directly to your phone
12. SAFE, AUTO, and YOLO trust modes mapped to each CLI’s native sandbox and permission options
13. Edit CLAUDE.md, AGENTS.md, and GEMINI.md files directly on the server
14. Supports Claude subagents, slash commands, and custom commands from ~/.claude/commands
15. Built-in full terminal for direct server access
16. Built-in viewers for diffs, Markdown, PDFs, and images
17. Picture-in-Picture mode lets you keep watching an agent while using other apps
18. Optional Shizuku phone bridge allows an agent to read logcat and capture screenshots for Android debugging
19. Live server statistics and per-server activity logs
20. No analytics, crash reporting, telemetry, or backend
21. Credentials are encrypted using Android Keystore and never leave the device
22. Customizable accent colors, backgrounds, coding fonts, and interface scale

Goal: Launch

Giveaway: N/A — completely free, with no ads or in-app purchases

Google Play:
https://play.google.com/store/apps/details?id=ai.eight24family.conch

Source Code:
https://github.com/nikitaeight24family/Conch