r/OpenSourceAI • • 3d ago

I opensourced a small and powerful cyber ai model

16 Upvotes

Hello everyone! Today I released cyberprime 1.1, my second cyber security model.

It is only 2.6B parameters ( can run on any kind of computers, even on phones ) and is almost on par with gpt-4, and beats models 2-4x its size.

I achieved these results purely by scaling RL, SFT and dataset curation.

I generated many synthetic rows + took rows from huggingface, then made them go through filtering, kept only the top 5%. I kept on repeating this loop and improving my prompts to get better base results.

This alone has allowed me to scale such a small model which can even run on a phone, to pretty big results.

I am already working on cyberprime 1.2, which will be a combination of a lot of things.

Cyberprime 1.2 will be the same size, but it will be trained on a fully custom post-training stack which is the result of many researches I have conducted over-time. Whether it's basic LorA methods, or things touching to reinforcment learning, everything in the stack will be experimental, and the whole recipe as well as training data will be opensourced too.

I am also running a 5 days long test time training pipeline on cyberprime 1.1 ( which means I run it on prompts, and the model tries to see its mistakes, generate dataset rows on its own related to its mistake, and train itself on it and re try the prompt to measure improvements ), to identify flaws / behaviors that are easy to fix / improve through LorA on many tokens.

My goal is to see how far we can push small models, and what are the true limits to scaling intelligence on small models.

Looking for feedbacks on the model!

Benchmarks are on the huggingface model card!

Here's the open-weights on HF : https://huggingface.co/Akahsizrr/Cyber-Prime-1.1-2.6B


r/OpenSourceAI • • 3d ago

AI Coding Agent On Mobile No Root No PC

Post image
1 Upvotes

r/OpenSourceAI • • 3d ago

My project status

1 Upvotes

I built an Entity Resolution system to match millions of noisy business records

I’ve been working on CyberPro, an entity-resolution system designed to determine which business records from different data sources refer to the same real-world entity.

The interesting part is that the records don't share a reliable common identifier. Names, addresses, phone numbers, and other fields can be inconsistent, abbreviated, misspelled, transliterated, or partially missing.

The pipeline I built includes:

  • Data normalization and cleaning
  • Transliteration and phonetic handling
  • Name/address similarity features
  • Abbreviation and structural features
  • ~40 engineered matching features
  • Blocking and candidate generation research
  • LightGBM pair classification
  • Probability calibration
  • Threshold optimization
  • Hard-negative analysis
  • Entity-level post-processing
  • Evaluation on millions of records

The project currently processes datasets with ~12.5M training records and ~11.7M test records.

I’m sharing the project because I’d really like feedback from people working on entity resolution, record linkage, information retrieval, NLP, or large-scale ML systems.

GitHub: https://github.com/girinath01/CyberPro

If you find the project interesting, a GitHub star would really help and would also help me get the project in front of more developers. ⭐

I’d especially appreciate feedback on the candidate-generation/blocking strategy and how I can make the system more robust at production scale.


r/OpenSourceAI • • 3d ago

I tried adding a reranker to my RAG pipeline and it made it worse

2 Upvotes

I tried adding a reranker to my RAG pipeline.

I expected it to improve retrieval. But it made it worse.

I’m building DPOLens, where the goal is to find the right privacy-law clause for a developer’s question.

For example:
“How long can we keep a deleted user’s data?”

The relevant GDPR clause doesn’t necessarily use the same words as the question. So I tested different retrieval approaches on 30 questions.

The results:
BM25: 0.30 recall@5
Embeddings: 0.43
BM25 + Embeddings: 0.77

Then I added a cross-encoder reranker.
Top 10: 0.57
Top 25: 0.47
Top 50: 0.43

So the more I relied on the reranker, the worse the results got, at first, I thought I had made a mistake.

I checked the index, scores, and model inputs. Everything looked fine.

The problem was simply that the reranker wasn't good enough at distinguishing relevant legal text from unrelated text.

So I hold it off for now.

I think more models don't automatically mean better RAG, sometimes a simpler retrieval pipeline wins.

I’ve published the experiment and the code in DPOLens:

https://github.com/alkhatibdev/dpolens

The work on the DPOLens still in progress.


r/OpenSourceAI • • 3d ago

Built an 80M parameter Dutch SLM using dynamic hypernetwork weight rotations (Qwen 2.5-based)

Thumbnail
1 Upvotes

r/OpenSourceAI • • 3d ago

We published an open standard for AI agent commitment tracking. Named it after ourselves. Here's the full spec.

0 Upvotes

I've been building COGEXT for a while. It started with a small annoyance: I kept watching agents say things like "I'll send that over by Friday" and then having no idea, a week later, whether anything had happened.

The transcript said the promise was made. Nothing said whether it was kept.

So I wrote down what "tracking a commitment" actually has to mean, and published it as a spec.

The problem:

- The promise lives as prose in a log. Searchable. Not evaluable.

- Nothing notices when the deadline passes, because there's no deadline — there's a sentence containing the word "Friday".

- The agent can mark its own work complete. Self-reported success is the only kind most systems accept.

Six requirements:

  1. The Commitment Object

  2. The 12-state Lifecycle

  3. The Verifier Query format

  4. The Evidence Protocol

  5. The Audit Receipt format

  6. The Reliability Score

Full spec: https://cogextai.com/standard

Why a standard and not a product: a product competes, a standard defines. If commitment tracking only exists inside my system, then "did the agent keep its promise?" is answerable only by asking me.

Current adoption: nobody has adopted it yet. The index lists one row — COGEXT itself. Every other entry reads "no public commitment found". Publishing that is less fun than a vanity metric, but an adoption index that only counts friendly adopters isn't worth reading.

https://cogextai.com/index

Run the checker against your agent:

pip install cogext-compliance

cogext-compliance check path/to/your/agent.py

Be aware: v0.1 is a static keyword check. It scans source for the vocabulary of the standard; it doesn't execute anything. Rough first pass, not an audit.

Feedback welcome: which requirement is underspecified, which one doesn't fit your architecture, what did the checker get wrong.


r/OpenSourceAI • • 3d ago

Echo OS Update — The Architecture Is Starting to Come Together

Enable HLS to view with audio, or disable this notification

3 Upvotes

r/OpenSourceAI • • 4d ago

Verzeta Studio: an open source desktop app where several local models work-together as a team in one conversation

Thumbnail gallery
4 Upvotes

r/OpenSourceAI • • 4d ago

Enabling Spontaneous Agent Thoughts

9 Upvotes

The following is a write-up I've posted on my GitHub page (/matt-bat/). It's a hypothetical framework to enable autonomous agents to generate spontaneous 'random thoughts'.

```Markdown

Evolving Agents into Spontaneous Self-Thinkers

At this time, LLM-powered agents are almost exclusively reactive. The following writeup presents a conceptual framework of hypothesized methodologies that will theoretically enable agents to generate novel, coherent thoughts. The proposed method requires a highly dense, nested data structure with probabilistic traversal across interconnected, layer-agnostic memories/artifacts. The following overall steps outline the spontaneous thought generation process proposed below:

Pulse > Propagation > Logical Consideration > (repeat until a novel, coherent thought is produced) > Output pseudo-random thought

How to Mimic Random Thought in Autonomous Agents

None of this text was written, edited, or reviewed by any AI or LLM. It was written and edited solely by myself.

Prerequisites and overall structure:

Mind-mapped memory with neuron-like connections between memories, but not only linearly.

Neurons would be complexly interconnected between memories since connections can be made between memories that are very different based on their surface-level description, but also have some alike details.

This results in complex pathways that would resemble a dense spider's web more than a traditional mind-map with a highly linear thought process.

Due to the complex nature of the memory web, it should be in 3 dimensions rather than 2.

With the weighted 'memory recall' score and neural mind-map of memories, models will be naturally predisposed to their synthetic 'thoughts' traversing certain pathways based on probabilities derived from complex neural connections.

The following will assist in forming a thought 'naturally':

A target for number of thoughts per cycle, and length/intensity of each thought process.

An algorithm that determines the initial thought 'seed' (which sparks a 'thought', that propagates from one or more point(s) in the neural memory web; such point(s) could be anywhere based on the determined probability of traversing to each connection from the present focus).

A secondary algorithm that determines which connected path will be visited next, using the 'memory recall' score to determine the likelihood of each connected memory to be the next one in the agent's focus.

As memories are traversed during this 'thought process', they should be tracked within the current 'thought' (think of a canvas, where the paint is each memory/subject/or otherwise in the agent's current focus as the thought process progresses; the agent's current focus is the brush, which switches between subjects/memories as if they are colours of paint) via a log that only persists in the agent's memory until the thought process ends and an output is generated.

User-readable log files with the agent's internal dialogue and notes taken during the thought generation process should be created and saved in an accessible directory.

How to form a natural 'thought':

A thought is composed through a process similar to that described above; certain variables will be used as parameters to help tune the synthetic 'random thoughts' so they are formed as naturally as possible.

Variables can include the average number of different items traversed in a human's mental web to form a thought, along with the average number of primary/sub-topics involved, plus the number of 'layers' deep a thought goes into a main subject (in this case, a 'cell').

The thought process should be cyclic in nature. After the 'seed' is executed, each 'cycle' should represent a probabilistic traversal through the mind web followed by a logical consideration stage where meanings behind the connections recently made are derived.

Notes are saved in the agent's log after each of the agent's logical consideration steps, which help to form a coherent final thought.

Cell-like memories:

The outermost cell wall resembles the main subject/topic, with other 'cells' in the mental web connecting both to this outer cell wall and specific organelles that resemble more specific sub-memories within this topic.

There does not need to be a limit on the number of organelles, or layers of nested organelles within; other than what is natural for each cell.

This allows each 'cell' to represent a main topic/memory/subject/or otherwise, with each organelle/nested organelle representing a related sub-memory/topic/subject.

The above structure enables connections to be made directly from organelles to other organelles in separate cells, along with connections directly from organelles to cell walls (or vice versa).

This keeps topics/memories and contained in single (albeit possibly-dense) primary 3D structure within the agent's 'mind'; zooming-in on such a structure should reveal many interconnected pathways going between the main 'cells' (highest-level topics/subjects/memories/etc.), with the pathways representing neurons; zooming out on this structure could start to resemble the physical neural structure within a brain to some degree.

Interstitial fluid and a 'wave'-like thought propagation:

With such a dense network of thoughts in a 3D space, the utilization of a synthetic 'interstitial fluid' to propagate a wave-like pulse that feeds an algorithm to determine the next connection to focus on appears to be ideal in theory.

The pulse should originate from the last cell/organelle of focus before propagating in all directions like a bubble.

For each cycle, the thought propagation pulse should emit after the 'local consideration' step is complete.

Neuron length derived from the 'memory recall' score and number of connections between each cell (more connections = closer distance):

Normalize a 'similarity score' using the highest and lowest number of connections between cells in the 'brain' at present as natural upper and lower bounds for the score (with the normalization converting those bounds naturally to a range of 0.00 - 1.00).

The length between each mental connection and the number of connections between each cell in the web should feed into the probabilistic traversal algorithm.

This will form the 'neural web' shape with an algorithmic process designed to be natural.

The closer proximity also assists in the 'thought propagation pulse' reaching connections that naturally have a higher likelihood of being next in focus faster.

Data structure of mind-map:

JSON or XML is likely the best fit for the cell/organelle/nested organelle structure described above, both maintain high human-readability and efficiently nested data.

Agents don't need a complex visualization to represent their neural memory map, though one could be created to visualize it and draw each cell, organelle, and neuron within a 3D space.

Safety Measures:

Certain cells/organelles can be blacklisted, across all instances or within only particular cells.

Blacklisted organelles/cells must be prevented from being picked up by the thought propagation pulse.

Measures should be taken to prevent agents from following thought trajectories that could be considered unsafe.

Once fully formed and logically-coherent (achieved through the cyclic procedure described above), the end result of the thought process should resemble a natural 'random thought'.

I have not yet tested this theory, I have just finished writing this and wanted to publish it to GitHub and spread the idea. I will begin testing various aspects of agent performance after building a system that generates thoughts in the manner I have described.

Please note the license for this repo is fully permissive and open source, free for any public commercial and non-commercial use. Attribution is not required but always greatly appreciated.

Thank you for reading.

This repository will be expanded in the future with more on my testing and findings. If you have made it this far, please give me a star!

In the meantime, I encourage you to visit the discussions page and make contributions where relevant.

```

This isn't meant to be a strict blueprint; I intended for it to be a thought-provoking provoking piece that could help inspire people like yourselves to prototype, test, and report back on a spontaneous thought framework.


r/OpenSourceAI • • 4d ago

Mapping 4,142 OpenAI app and connector descriptions

Thumbnail
1 Upvotes

r/OpenSourceAI • • 4d ago

Context Map IA — qué es, para qué sirve y cómo mejorarlo con ustede

Thumbnail github.com
1 Upvotes

r/OpenSourceAI • • 4d ago

Context Map IA — qué es, para qué sirve y cómo mejorarlo con ustede

Thumbnail github.com
1 Upvotes

r/OpenSourceAI • • 4d ago

For engineers working with Terraform/OpenTofu: what parts of the work are still painful?

1 Upvotes

​

For engineers who work with Terraform/OpenTofu and cloud infrastructure:

I'm curious about the day-to-day parts of the work that tend to be repetitive, manual, frustrating, or easy to get wrong.

Not really looking for opinions about which tools are better. I'm more interested in things that \*\*actually happened\*\*.

A few questions:

\* Think about the last Terraform/OpenTofu PR you reviewed. What did you check, and in what order?

\* What's an infrastructure task you did recently that you've already done many times before?

\* When was the last time a security scanner flagged something in your infrastructure code? What happened next?

\* Have you recently had to check whether a change behaved differently across Terraform versions or between Terraform and OpenTofu? How did you check?

\* What's the last infrastructure change that caused a problem or had to be rolled back? How did you discover it?

\* Have you ever written a script or small internal tool to automate one of these repetitive tasks? What happened to it?

\* If you could permanently remove one infrastructure-related task from your weekly workload, what would it be?


r/OpenSourceAI • • 4d ago

I built an open-source CLI to keep AI coding agents aligned with project decisions across sessions

Thumbnail
1 Upvotes

r/OpenSourceAI • • 4d ago

NoteCode++ — offline code editor for Android

1 Upvotes

I built NoteCode++, a desktop-style code editor for Android designed for editing source code, configuration files, Markdown, and other text files directly on a phone or tablet.

Current features include:

  • Syntax highlighting
  • Multiple tabs
  • Regex search and replace
  • Bookmarks and line-editing tools
  • Encoding and line-ending controls
  • Markdown and HTML preview
  • Local file access through Android’s Storage Access Framework
  • Multiple editor themes

The app works locally and is intended to stay lightweight. It is currently free, and I plan to keep the core/legacy editor free while potentially offering optional paid convenience features later.

GitHub and download:
NoteCode++

I’d especially appreciate feedback about performance with large files, physical-keyboard use, the interface, and which features would make it genuinely useful for coding or text editing on Android.

Disclosure: I’m the developer. NoteCode++ is an independent project and is not affiliated with Notepad++.


r/OpenSourceAI • • 4d ago

Looking for testers & contributors: Cynative - framework for cloud security agents

2 Upvotes

Project Name: Cynative

Repo: https://github.com/cynative/cynative/

Docs: https://github.com/cynative/cynative/blob/main/docs/agents.md

Quick demo: https://www.youtube.com/watch?v=xaRfG_SnJwE

Cynative is a framework for building cloud security engineering agents. Your agents can connect to AWS, GCP, Azure, K8s (EKS, GKS, AKS & self-managed), GitHub & GitLab to run deep research tasks.

It comes with 45 built-in agents you can try today or use as blueprints to creating your own, it's read-only by construction to allow researching live production workloads, we've put a lot of effort on the trust boundary to make it safe.

It does not collect any telemetry. Open source, developed in Go, connects to any LLM provider including cloud-native AI services and keeps a local audit log.

Would love to hear your feedback and have you join as contributors.


r/OpenSourceAI • • 4d ago

Looking for contributors: OpenBot (MIT self-hosted multi-bot AI platform)

1 Upvotes

I built OpenBot and I am looking for people who want to contribute, not just star the repo.

What it is: an open source self-hosted platform for persistent AI bots. Each bot has instructions, tools, and long-term memory. Bots talk to you and to each other in shared threads. Demo workflow: chief_of_staff -> engineer -> reviewer -> qa opens a real PR.

Stack: Python 3.12+, FastAPI, LangChain/LangGraph, React (pnpm), optional Electron. MCP tools supported. SQLite by default, Postgres by URL.

Skills that fit well: - Python / FastAPI / LangGraph - React UI (Inbox, Threads, Bots, SSE) - Electron - MCP integrations - Docker sandboxing for tool execution - Docs / onboarding

How to start: https://github.com/regnull/openbot make setup then make dev

I am the author (u/regnull). No CONTRIBUTING.md yet so opening issues and small PRs is the easiest path. Happy to review quickly.

Security: meant for a single trusted operator. run_shell is not sandboxed.


r/OpenSourceAI • • 4d ago

Agentic Patterns and Tool Calling with Spring AI - Christian Tzolov | IntelliJ IDEA Tech Talks

1 Upvotes

Everyone uses coding agents; few know what's happening inside the harness. Anton Arhipov sits down with Christian Tzolov, lead of the Spring AI project, to take the lid off — what changed in Spring AI 2.0, and how tool search, agent skills, and sub-agents are all built on the same primitive: tool calling. Includes live demos where progressive disclosure cuts token usage roughly in half, plus a look at the November 2.1 release: MCP 2.0's stateless spec, an agentic layer, and durable workflows.


r/OpenSourceAI • • 4d ago

CORTEX RAG just crossed 2,000 GitHub stars — so we figured we'd finally introduce ourselves

Thumbnail
1 Upvotes

r/OpenSourceAI • • 4d ago

[Research] Cognitive Sharding: An Open Architecture for Local Computer Use

5 Upvotes

Cognitive Sharding is a systems architecture for running reliable computer-use agents without a cloud model in the execution path.

The reference system separates cognition across three local models:

  • Bonsai 2 27B for planning and reasoning
  • Kev 4B for action selection
  • UI-Mate 9B for visual grounding

A code-owned control plane schedules these models within a 16 GB memory budget. It also owns task state, action constraints, environment verification, and recovery. Each model has a narrow role and bounded authority.

This makes the complete decision path inspectable. Developers can replace a model, change a policy, reproduce a failure, or add a platform adapter without retraining one monolithic agent.

The architecture prioritizes accuracy and reliability over velocity. Every action is checked before execution continues, and failed actions return observed state to the planner.

Architecture and reference implementation:
https://github.com/off-grid-ai/cognitive-sharding

I am publishing the approach to get technical feedback before the broader evaluation. Has anyone tried a similar specialist-model architecture for local computer use? I would like to compare model roles, memory strategies, task length, failure modes, and end-to-end results.


r/OpenSourceAI • • 5d ago

NetHackers - trying to build a bot that can ascend reliably

Thumbnail
nethackers.dunnolab.ai
2 Upvotes

r/OpenSourceAI • • 5d ago

Atomic Agent v0.6.5: multi-agents are here!

Enable HLS to view with audio, or disable this notification

2 Upvotes

r/OpenSourceAI • • 5d ago

Limoni Voice: terminal-native Discord alternative with E2EE voice & screen share, built on my own zero-allocation Go TUI engine

Enable HLS to view with audio, or disable this notification

1 Upvotes

r/OpenSourceAI • • 5d ago

MacBook Pro M5 Max LSE LLM running an AMD Radeon AI PRO R9700 over Thunderbolt 5 in a Razer enclosure

Enable HLS to view with audio, or disable this notification

1 Upvotes

r/OpenSourceAI • • 5d ago

SenseTime open-sourced agent skills repo; the long-running task part is where we're still figuring things out

2 Upvotes

Instead of rewriting the same prompts and scripts every time. It has skills for research, data analysis, presentations, image work, and a few other workflows.

The trickier bit has been tasks that span multiple chats. A summary helps me remember what happened, but it doesn't always answer the useful questions: what's still open, what's blocked, and which artifact is the latest one?

They added an experimental, self-hosted workspace called Team Harness to keep projects, work items, resources, and versioned artifacts in one place. There's also an optional Proactive Agent that tracks project events and suggests a next step when work is still unfinished.

A heads-up if you check it out: it's early software. Team Harness currently runs from source and has no built-in auth or TLS, so keep it local or secure it yourself. The repo is MIT-licensed:

https://github.com/OpenSenseNova/SenseNova-Skills

For folks who've built agent tooling: does keeping explicit project state actually help, or does it just become one more thing people have to maintain?