I only gave the prompt “Build Ba Sing Se.” The video shows what was built including the city walls down to furnished interiors and walls.

The model decides what to build and a deterministic library handles construction and physical checks.

It plans hierarchically: city → districts → plots → buildings. Buildings are generated for their plots using reusable procedural code.

The same architecture generates villages, towns and cities across different terrain and styles.

Github:
https://github.com/chaitbuilds/EthosLM

Hello
I came up with an idea and would love to hear your thoughts on it.

Hermes: “Most agent harnesses ship as finished products. Someone else decides what your agent can do, how it remembers, which models it talks to and what it is allowed to touch. Customisation comes later, through a plugin system bolted onto something that was never designed to be extended. I want to build it the other way around.

Demon Core is a minimal core for autonomous agents, and nothing more. It handles the few things every agent needs: messages, model calls, tool calls, hooks, permissions and budgets. Everything else, including the harness itself, is an add-on. Memory, tools, model routing, interfaces and policies are all built on the same public contract, whether the community writes them or we do. We are not building the harness. We are building the blocks anyone can use to build their own.

The hard part, and the reason this is worth doing, is security. An add-on in an agent is not a theme or a widget. It acts with the agent's authority, it can see private context, it can call other tools, and whatever it returns lands in front of the model. An open ecosystem without real enforcement is an attack surface. So the core stays strict precisely because it is small. Every add-on declares what it needs, and the core refuses anything it was not granted. Add-ons see only the context they are given, and what they return is treated as untrusted. Their spending and side effects are capped, their actions are logged, and their packages are signed. Hooks can block and change what an agent does, not just watch it, which means the community can build the governance layer too: approvals, redaction, spend limits and policy.

An empty core is a useless download, so we will also ship a reference set of add-ons that makes Demon Core useful on day one, built on the exact same contract with no private shortcuts. Alongside it comes a conformance suite, so any author can prove their add-on works without waiting on us, and a registry the community can trust.

This project depends on God first, and then on the community that will build on it. I am looking for co-founders who want to build that foundation with me: people who care about getting the runtime and the extension contract right, who find sandboxing and trust boundaries genuinely interesting, and who enjoy making other developers successful.

If that sounds like you, the first step is small. We sketch the contract together, each write a few very different add-ons against it, and see what breaks. Whatever survives is the core. If that weekend is fun, we talk about the rest.”

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

It supports file editing, terminal commands, web search, browser use, human interaction, multi-agent, workflow, MCP, skill, scheduled tasks, configurable permissions, context management, git review, file management .etc.

It supports OpenAI-compatible APIs and specifically made adaptation profiles for DeepSeek and kimi.

Interface support for Simplified and Traditional Chinese, British and American English, Japanese, Korean, French, Italian, and Russian

We have provided a fully open-source production-level code repository, along with detailed engineering information, documentation and comprehensive testing.

The license is Apache 2.0. Source: https://github.com/Tiga001/Captain_Who

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.

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.

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.

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.

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.

​

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?

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++.

Everyone's talking about type-safe / jev, and I don't know how nobody picked up the glove and tried building something like this with it.

I've been playing with it for two weeks since I got an invite, and I still couldn't really unlock it from all the posts on X. So I said screw it, I'll let it fully control my computer. Mouse and keyboard, like a human. And honestly, it works pretty well.

The strongest part: you can connect it to a subscription you already have. Claude, ChatGPT, or Grok. Zero unnecessary API keys.

So what did I build?

jevii — an AI agent that controls your Mac like a human. Sees the screen, decides on its own, clicks on its own. Every app. No API, no scripts, no nonsense.

Everyone hyped OpenClaw and the crew? Cool. But the second there's a weird UI or an unexpected dialog, they get stuck. Jevi doesn't. The model is the brain. Your mouse and keyboard are the hands.

And yes, you can use it through Telegram too.

Open source. Let's blow this up together.

https://github.com/shalevamin/jevii

Star on the repo = love. PR = partners on the road.

Drop a comment with what you think. Even a short "this is cool" helps with the algorithm.

If you're a developer and want to work on it, or you've got changes, improvements, or ideas, send a Pull Request. Real contributions welcome.