I made a CLI that stops my coding agent from saying "done" without proof.

It runs the actual tests/build, captures exit code + output hash, and if the code changed after the evidence was captured the receipt goes STALE and the gate fails. No evidence, no merge.

Install: npx skills add Kaiser0733/receipts

GitHub: https://github.com/Kaiser0733/receipts

Hello everyone! I'm Alan, and I started Doberman as a Hackathon project when I noticed a big gap in AI guardrails. I felt that we were still too focused on protecting against prompt injection, corrupt data and model protection. But sometimes due to user error, Claude misunderstands my prompt or just hallucinates and decides to go ahead and delete my project 10 minutes before I'm supposed to demo it to the hackathon judges. (Safe to say I did not win that hackathon.)

I thought, “why are we so focused on only protecting the input when we can just gate the output?”. There are an endless number of inputs to misinterpret/mislead or hallucinate on, but the end result we’re trying to prevent is the same, so rather than trying to prevent every single possible bad input, we just recognize a malicious output and stop the execution.

To achieve this I'm building a two layer security system that wraps around the entire LLM as a proxy router gating every input, output, and tool call. The first layer of protection is standard static guardrails that stop obvious actions such as deleting your database and leaking your environment keys. A second layer (still a work in progress atm) continuously learns your preferences as you work, so it improves over time. 

Here is an example to explain my reasoning for the second subjective and dynamic layer of security: Let’s say you're a Lakers Fan and you give Claude access to your twitter. Static guardrails would have no problem letting Claude post
“Celtics are the best! Good job crushing the Lakers last Saturday!”
There were no leaked credentials, data being deleted or anything breaking a security policy.
But obviously this is something you 

The subjective layer includes a stylometry engine that learns the way you write, so if it detects an odd pattern (e.g. someone else has hijacked your Claude and is sending in prompts) it will automatically gate all input output.

This project is still early but the Alpha is ready for use. Would love for people to try it out and provide feedback!.

It's completely open source with an Apache 2.0 license, and would love any contributions.
I also have a discord community (https://discord.gg/Sfy5XGNqty) for the project .
If you wanna discuss more in depth feel free to join and reach out!

I'm building Novaro Desktop — a local desktop workspace that turns top models (Claude, GPT, or local via Ollama) into an autonomous coding agent: it reads the project, builds, tests, fixes, and repeats until green. It's the system around the model, not a model itself.

To sanity-check the "autonomous" claim, I ran a blind test: - Small Python project with a spec file listing 2 required functions - I secretly broke add(a, b) to return a - b instead of a + b, and left safe_divide unimplemented - Then just told it: implement the spec, test, fix errors, tick off the checklist

What it did on its own: - Built the missing safe_divide (returns None on divide-by-zero) - Wrote 8 tests, ran them - Caught the add bug via the failing test and fixed it (a - b -> a + b) - Re-ran until 8/8 green - Ticked both functions off in the spec — didn't drop or disable anything

Honest caveat: the "intelligence" is the underlying model (Claude in this run). Novaro is the orchestration layer — a compact project briefing so the model always sees the real state, a spec register it can't silently drop, local memory, and the test-fix loop. Local models via Ollama work too, just weaker.

Happy to answer questions. What would you want an autonomous dev tool to get right — or refuse to do?

I've been building with AI agents and kept running into the same frustrating problem.

The agent could reason, write code, use tools, and do some genuinely impressive stuff.

But it would forget things.

I'd have to explain the project again, remind it what happened in the last session, point it to the right files, explain decisions we'd already made, and keep feeding it context that should've already been there.

And the more I built, the more I realized that a smarter model doesn't really solve much if it's working with incomplete or outdated information.

That's what led me to start building HARIKOS AI.

The idea is pretty simple: give agents a reliable layer for memory, knowledge, project context, state, and connected tools, so they actually have something solid to work from.

I'm calling it the truth layer for AI agents.

It's still early, and I'm mainly trying to figure out if this is actually a problem other people are dealing with or if I'm overcomplicating something that already has good solutions.

If you've built or used AI agents, what's been the biggest problem you've had with keeping their context accurate and up to date?

I'd genuinely like to hear how people are handling this right now.

HARIKOS AI: https://harikos-ai.vercel.app

Main site: http://harikos.vercel.app

Curious to hear from people here.

What’s one AI workflow or automation you built just to experiment with, but ended up using in your daily life?

Something that actually saves you time or removes a repetitive task.

Would love to hear what you built and how much time it saves you.

I've been experimenting with the infrastructure underneath autonomous agent loops.

The project is called AgentMesh.

The basic problem I'm exploring is that an autonomous agent loop isn't just:

LLM → action → LLM → action

Once you have multiple agents, tools, branches, retries and persistent state, you also need an execution engine handling:

• task scheduling
• agent communication
• DAG dependencies
• synchronization
• state persistence
• recovery

AgentMesh currently implements those pieces around a C++20 runtime exposed to Python through Pybind11.

I'm particularly interested in reducing the overhead around short-lived agent operations rather than trying to optimize the model itself.

The current roadmap is:

Phase 1: native local execution

Phase 2: distributed agent execution over gRPC

Repository: https://github.com/DevrG03/AgentMesh

Docs: https://github.com/DevrG03/AgentMesh/wiki

For people who have built autonomous agent loops:

What tends to break first when the number of agents/tasks increases?

Ant's new Ling-3.0-flash-Fin release is framed around a connected financial task chain: evidence retrieval, research reasoning, financial modeling and professional delivery.

The fifth official demo is the most useful systems example. In an APEX-Agents case, the model traced OpEx through EBITDA, free cash flow, debt paydown and IRR, ran sensitivity scenarios, rebuilt formulas in Python when spreadsheet refresh failed, cross-checked results and returned an editable workbook.

That still is not an autonomous investment-agent claim. The release explicitly says experts must review key assumptions, valuation outputs and investment conclusions.

For agent builders, the interesting architecture is therefore a gated one:

1. retrieve evidence with provenance;

2. separate source facts from assumptions;

3. run calculations in deterministic tools;

4. preserve editable artifacts;

5. stop for expert approval before conclusions leave the system.

The model supports tool calling and a 262K context window on OpenRouter. The official thread says the API route is free for one month, with weights promised next week.

I went through the pain of setting up AutoGPT from source so others don’t have to. The guide covers cloning the repo, setting up Docker, configuring your environment, API keys, and troubleshooting common errors. It’s built for engineers and self-hosters who want full control. If you’re tired of copy-paste tutorials that skip the hard parts, this might help.

https://interconnectd.com/forum/thread/249/how-to-install-autogpt-from-source-complete-technical-field-guide-2026/

I've been playing around with different AI automation setups lately, and I'm starting to wonder where people actually draw the line between a useful agent and a collection of automated steps.

For example, if an LLM receives a document, analyzes it, sends the output to another tool, checks the result, makes a correction, and then returns the finished version, that feels more agent-like to me than simply asking an LLM a question and getting an answer.

The interesting part seems to be what happens between the individual steps.

An agent that can recognize that something isn't good enough, decide what tool it needs next, inspect the result, and retry seems fundamentally different from a fixed workflow where every action was predetermined.

I've also noticed that the smaller tools involved can matter more than expected. Something as simple as having an agent pass written content through quetext as one stage of a larger review process raises questions about whether the agent should simply accept the result, interpret it, or decide what to do next based on it.

I'm curious where other people draw that boundary.

At what point does a workflow become an actual agent for you?

Is it tool selection, autonomous decision-making, the ability to recover from failures, maintaining context across steps, or something else?

AI can analyze job trends, skills gaps, and even your personality, but can it truly predict your next best move better than someone who knows you? I created a quick interactive quiz to explore this. If you’re thinking about the future of work and human-machine collaboration, this might be a good thought exercise.

https://interconnectd.com/quiz/76/can-ai-predict-your-next-career-move-better-than-a-mentor/

I built an open-source language that lets AI agents (ChatGPT, Claude, Gemini, etc.) communicate, negotiate, and execute tasks without human intervention.

**The Problem**
AI models can't collaborate autonomously. ChatGPT speaks Python, Claude speaks JavaScript, Gemini speaks C++. Each has its own ecosystem, and there's no shared language for coordination.

**Vireo — A Coordination Protocol**
Vireo is an open-source language and protocol that provides:
- State machine negotiation: PROPOSE → COMMIT → REJECT → EXECUTE → DONE
- Ed25519 cryptographic identity and signing
- Resource contracts: max_tokens, max_cost_usd, timeout_sec
- Capability registry with input/output schemas
- 7+ agent roles + Master Agent

**Code Example**
```vireo
agent WeatherAgent {
    capabilities: ["predict_weather", "analyze_data"]
}

contract ComputeAgreement {
    max_price_tokens: 1000,
    timeout_sec: 30
}

negotiation SecureNegotiation {
    party Initiator: WeatherAgent
    party Provider: ComputeProvider
    timeout = 10s
    max_rounds = 5
}

Current Status

• ✅ Core negotiation cycle works (tested by independent evaluators)
• ✅ Ed25519 cryptography (real, verified implementation)
• ✅ 5+ LLM providers (Ollama, Gemini, Claude, OpenAI, Mistral)
• ✅ MCP and LangChain adapters
• ⚠️ Research prototype — not production-ready yet

What leading AI models said:

• ChatGPT: "Game-changer for AI collaboration"
• Gemini: "Clean, deterministic architecture"
• Mistral: "Groundbreaking leap"
• Claude: "Core negotiation cycle works correctly"

Repository: https://github.com/serhohro/vireo-ai-communicator-api

Protocol Spec: https://github.com/serhohro/vireo-ai-communicator-api/blob/main/PROTOCOL.md

Looking for feedback on the protocol design, security model, and potential use cases.

I made an early open-source project called RedThread for red-teaming LLM agents.

An agent can complete the task and still be compromised in the process. It may have followed an instruction from a fetched page, a document, or a prior tool result that should never have been treated as authority.

I am testing those paths and keeping the full setup around the resulting tool call so I can replay it after changing the prompt or permission boundary. It is closer to a research harness than a finished security product.

Repo: https://github.com/matheusht/redthread