Tenma retweeted
Over the past few weeks, i had been implementing a runtime layer where it sits between an LLM's intent and the tools it tries to call.
Answering a silly question, i.e., if LLMs are getting stronger every day, why do we need a layer between the model and the tools it calls?
Hence, introducing Aegis, a reliable runtime layer for LLM tool calling agents
Tenma retweeted
plenty of log tools buffer the whole file into memory. a 100 gb log needs 100 gb of ram.
oculus doesn't. it streams. 1m lines parsed in 0.65s, with a flat ~5 mb of ram whether the file is 1 mb or 100 gb. it's a rust-based dev utility cli tool that turns apache, nginx, and json logs into structured summaries.
memory stays o(1) because it streams every line and drops it. lazy parsing, buffered i/o, flamegraph-driven optimization, and a lot of tuning did the rest.
open source, benchmarks on github:
github.com/omanshchoudhary/o…
Tenma retweeted
Launching Billy.
Creating an invoice shouldn’t feel like filling out paperwork. Most tools made it slower and more complicated than it needed to be.
So I built Billy, an in-browser invoice generator where you edit directly on the template, like editing a doc. No forms. No extra steps.
Built for everyone. But if you're a freelancer, indie hacker, or running a small business, this could genuinely change how fast you create and manage invoices.
Working on things like:
- Local-first workflows
- Templates
- Cloud sync
- Exports
- And more
Currently in waitlist mode, building otw.
Tenma retweeted
coding solve ho gayi AI se ab sab app banayenge, abey coding toh pehle bhi solved thi gavar podcastiye
Tenma retweeted
wrote up the blog after so many procrastination
spent 2 days like a zombie to write up this which no one’s gonna read prolly but we ball anyways 😭
writing up gave me more pain than building it lmao😭
anyways here’s the link -> akanshatwt.me/blogs/kafka-pa…
and with this im gonna take a good nap ;)
Tenma retweeted
today I dug into internals of Go maps and found that native maps in go are not thread safe.
concurrent access to map can lead to race conditions and crashes when we use it, sometimes in our work we might need some in house.
so today i built something for my sweet spot and usecase specific calling it `safemapp` using
small generic thread safe map with sync.RWMutex.
>Read operations use shared locks and writes use exclusive locks.
>Wrapped native map to avoid manual locking everywhere.
>Supports comparable keys and flexible value types.
>Added basic helpers like Get, Set, Delete and iteration.
this is useful for simple shared state across goroutines.
kept it minimal and focused on correctness
will explore on adding more over enginerring stuff later on, open for suggestions, improvements.
Tenma retweeted
We just launched @forg_to on @ProductHunt
Support us on - producthunt.com/products/for…
Giving pro (forg.to/pro) for FREE to first 100.
Forg is community of 500+ indie hackers , where you can
• showcase your work, exp, skill
• launch products,
• connect with builders
Tenma retweeted
Finally achieved this lemme tell you what the problem was
So we are using streams in the AI agent node provided by N8N
Now we have some mcp tools for solving user queries, so what we do is that we receive the user query, send an announcement for the particular query (1/6)
Tenma retweeted
CAP Theorem
CAP Theorem talks about tradoffs of disturbed systems
Here
C - Consistency (Every read request to the distributed system should return same result irrespective of whichever node we are reading from)
A - Availability (The system should respond to any request made to it irrespective of any node is failed or not)
P - Partition Tolerance (The system continues to respond/operate even though there is a network breakdown/partition between the nodes)
Before Diving into CAP theorem here is some background knowledge you should know
Distributed System : Data Stored in multiple servers instead of one(like we do when we apply horizontal scaling)
Why distributed systems?
> Spread Workload among multiple servers
> Can handle more number of requesss
> Improves overall performance
In distributed system we replicate same data across multiple systems to get the above benifits.
Server/s are called a node here.
Now let's talk about the CAP
Let's say there are there nodes X, Y and Z
Consistency says that whenever you read data from X, Y or Z they should return the same data and when you write then it should be propogated to other nodes to maintain consistency
Availability says that if B fails due to some hardware issue and go offline then A and C should still be working and should serve the requests
Partition Tolerance says if network partition happens on B and it can't communicate with A and C, then node B will still be serving requests even though it is not up to date with the data with other nodes(A and C) since it got a network partition.
CAP Theorem:
CAP Theorem states that in a distributed system, you can only guarantee two out of these three properties simultaneously. It's impossible to achieve all three
You can refer to the image below for clear understand about the statement once
Only the combination of
CA(Consistency-Availability), AP(Availability-Partition tolerance), CP(Consistency-Partition tolerance)
is possible
In distributed system there are very high chances of network partition so we should must handle P(partition tolerance).
So most of distributed systems choose either AP or CP because they can't afford network partition
What to choose between CP and AP
CP - if you can't afford inconsistent data then go for CP like banking, payment services where numbers are the most important thing
AP - if you can afford in consistent data but can't afford unavailability like social media can have slightly different likes, comments or views for different users but it can't have their apps down.
Tenma retweeted
EC2 and EBS in AWS.
EC2-
> EC2 is just a machine[computer with cpu, os, ram etc] hosted in cloud by aws which you can use to host your web frontend, backend etc
> These EC2 machines are stored in physical locations called availability zone
> There are many types of EC2 instances(you need to choose it based upon your application requirements)
t and m series are for less workload, c series are computer optimized, etc
[You can refer to the image attached below for the categories of EC2 instances]
> To launch an instance you need to select instance type + Operating System + Storage Capacity + Security Group(Inbound and outbound) + ssh key pair (to login into the terminal of EC2 instances from your laptop's terminal) + Availability zone(choose nearer zone based on traffic)
EBS-
> EBS is like a hard drive attached to your EC2 machine. They're used for persistent storage.
> EC2 has generally 2 types of storage
1. Instance Storage
2. Elastic Block Store(EBS)
1. Instance Storage
- It is a storage that is physically attached to the EC2 instance when you create and start it.
- If your EC2 goes power off or gets terminated then all the data stored here in instance storage will be erased since it is a non persistent storage
2. EBS
- It is a persistent storage which is not physically attached to the EC2 instance. Even when the EC2 instance is terminated the data will still be stored in EBS
- EBS is like an external harddrive
- if one EC2(let's say EC2-A) gets terminated which was using EBS, then the same EBS can be used in the new EC2(let's say EC2-B) and it will have the same data as EC2-A
- the EC2 instances and EBS should be under the same availability zone
Snapshots
> yk git commits?, by commits you can track changes in code, revert back to old code when something breaks. Snapshots does the same it captures the current data in the EBS and stores it.
> It is used for backups and it stores the disk blocks not files in S3(you don't manage this S3[we'll study about S3 in the upcoming post])
> Snapshots are generally taken daily to take back-up of the valuable data
Tenma retweeted
The Clawdbot → Moltbot → OpenClaw lobster has molted multiple times 🦞
The most interesting thing about Clawdbot isn't the bot but the ecosystem growing behind it.
---
Core:
Main repositories and branding roots of the personal AI assistant
• OpenClaw (current main repo for the personal AI assistant):
github.com/openclaw/openclaw
• Moltbot (old branding and website hub):
molt.bot
---
Deploys (no Mac Mini!):
Serverless, cloud, and self-hosted ways to run OpenClaw
• Moltworker (serverless Cloudflare deploy, ~$4/mo with AI Gateway):
github.com/cloudflare/moltwo…
• Molty (hosted version with improved UI for easy access):
molty.finna.ai
• AWS Bedrock (AWS-native deploy using Bedrock API integration):
github.com/aws-samples/sampl…
• DigitalOcean one-click / quickstart (easy Droplet setup guides):
digitalocean.com/community/t…
digitalocean.com/community/t…
• Coolify template (self-hosting Docker Compose template):
github.com/essamamdani/moltb…
• SetupClaw (in-person setup in SF/Dubai, includes Mac Mini option):
setupclaw.com
---
Skills Heaven (700+):
Plugins, automations, and workflows that extend Clawdbot’s capabilities
• Awesome OpenClaw Skills (curated community skills list):
github.com/VoltAgent/awesome…
• Clawhub (skill registry for discovering and installing plugins):
github.com/openclaw/clawhub
• Archived skills (full backup of historical Clawdhub skills):
github.com/openclaw/skills
• Agent Flywheel (advanced pro skills for coding and dev tools):
github.com/Dicklesworthstone…
• Lobster shell (workflow engine for composable pipelines and automations):
github.com/openclaw/lobster
---
Ecosystem:
Forks, memory layers, social graphs, and infrastructure around OpenClaw
• Lightkeeper fork (experimentation fork for tweaks and tests):
github.com/lightkeeper90/cla…
• OpenClaw org (16+ repos including plugins and infra):
github.com/openclaw
• Moltbook (social network for AI agents):
moltbook.com / xitter.gq/moltbook
• Supermemory add-on (long term memory via cloud recall):
github.com/supermemoryai/cla…
• memU memory (24/7 proactive memory to cut token costs):
github.com/NevaMind-AI/memU
• Clawdinators AWS hive (open-sourced hive-mind deploy):
xitter.gq/moltbot/status/2010130…
---
Start here:
openclaw.ai
or
github.com/openclaw/openclaw
---
What setup are you running? Drop below 🦞
🦞⚡ clawdinators is now open source!
Opinionated AWS deployment for @openclaw agents:
• NixOS + OpenTofu, zero manual steps
• Shared EFS "hive-mind" memory layer
• Auto-syncs with upstream commits
• Proper secrets management
Cybernetic crustacean organisms. Living shell over metal endoskeleton.
"I'll be back... after this deploy finishes"
github.com/clawdbot/clawdina…


































