DEV Community: Ramu Narasinga

Openship, a self-hosted deployment platform.

Ramu Narasinga — Wed, 02 Sep 2026 15:30:00 +0000

In this article, we review Openship. You will learn:

What is Openship?
Features

What is Openship?

Openship is an Open-source, self-hostable deployment platform with built-in CI/CD. Point it at a repo - it builds, ships, routes, and TLS-terminates your app. Drive it from a desktop app, web dashboard, or CLI.

I checked their docs and there are few important things worth mentioning about how you run Openship itself. There's three ways:

You are solo and run one machine, no ops:

It is recommended to run the Openship as a Desktop app. You can download Openship Desktop app Your apps run on a server that ssh over

You are a team/part of team

It is recommended to self host a server and spinup Openship.

Don't want to self-host?

Openship provides cloud alternative, starts from $10 per month at the time of writing this article, check their pricing.

Learn more about Openship.

Features

Openship handles everything between your code and production.

Deploy
Run
Connect
Data
Manage

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

I spent 3+ years studying OSS codebases and wrote 400+ articles on what makes the production-grade. Now I'm putting that into practice differently - instead of writing every fix myself, I run coding agents that do it.

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

What is Tauri?

Ramu Narasinga — Tue, 01 Sep 2026 15:30:00 +0000

In this article, we review Tauri. You will learn:

What is Tauri?
Tauri usage in worldmonitor repo

What is Tauri?

Tauri is a framework for building tiny, fast binaries for all major desktop and mobile platforms. Developers can integrate any frontend framework that compiles to HTML, JavaScript, and CSS for building their user experience while leveraging languages such as Rust, Swift, and Kotlin for backend logic when needed.

You can create a tauri app using the below command:

pnpm create tauri-app

after you create your project, you can check the project structure.

Why Tauri?

Tauri has 3 main advantages for developers to build upon:

Secure foundation for building apps
Smaller bundle size by using the system’s native webview
Flexibility for developers to use any frontend and bindings for multiple languages

Tauri usage in worldmonitor repo

I noticed the folder src-tauri, if you remember project structure generated using create-tauri-app, it looks like below:

javascript
.
├── package.json
├── index.html
├── src/
│   ├── main.js
├── src-tauri/
│   ├── Cargo.toml
│   ├── Cargo.lock
│   ├── build.rs
│   ├── tauri.conf.json
│   ├── src/
│   │   ├── main.rs
│   │   └── lib.rs
│   ├── icons/
│   │   ├── icon.png
│   │   ├── icon.icns
│   │   └── icon.ico
│   └── capabilities/
│       └── default.json

Tauri provides flexible architecture, any frontend framework is compatible with Tauri. That said, you might be wondering what Worldmonitor is.

Worldmonitor

I copied this info from Worldmonitor github.

Real-time global intelligence dashboard. AI-powered news aggregation, geopolitical monitoring, and infrastructure tracking in a unified situational awareness interface

What It Does

Curated news feeds across global and regional categories, AI-synthesized into briefs
Dual map engine — 3D globe (globe.gl) and WebGL flat map (deck.gl) with a shared map-layer catalog
Panel inventory — concrete panel implementations across specialized variants
Cross-stream correlation — military, economic, disaster, and escalation signal convergence
Country Instability Index (CII) — server-authoritative CII v8 stress scoring for the Tier-1 registry
Finance radar — stock exchanges, commodities, crypto, and a market composite
Local AI — run everything with Ollama, no API keys required
Site variants from a single codebase (world, tech, finance, commodity, happy, energy)
Native desktop app (Tauri 2) for macOS, Windows, and Linux
Multilingual UI with native-language feeds and RTL support

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Vue Flow usage in n8n codebase.

Ramu Narasinga — Fri, 28 Aug 2026 15:30:00 +0000

In this article, we review Vue Flow usage in n8n. You will learn:

What is Vue Flow?
How Vue Flow is used to build workflows in n8n.
Press enter or click to view image in full size

What is Vue Flow?

Vue Flow is a bridge to the world of interactive flowcharts and graphs, empowering you to bring dynamism and interactivity to flowcharts and graphic representations. Whether it’s crafting personal diagrams, generating dynamic editors, or anything else your imagination conjures up, Vue Flow is your creative companion.

Vue Flow makes it effortless to customize and extend basic functionalities by allowing the integration of your own bespoke nodes and edges. Additional components such as Background, Minimap, and Controls further enrich the interface, transforming your creations into engaging platforms.

Key Features

Seamless setup
Customizable
Efficient and Responsive
Utilities and Composability
Additional Components
Reliable

Check out the Getting Started guide.

How Vue Flow is used to build workflows in n8n.

I found the Vue Flow imports in the Canvas.vue file. n8n uses Vue in its frontend/editor-ui package.

// in Canvas.vue
import { 
  getRectOfNodes, 
  MarkerType, 
  PanelPosition, 
  useVueFlow, 
  VueFlow } from '@vue-flow/core';

Below is a code snippet I picked from the getting started guide:

<VueFlow :nodes="nodes" :edges="edges">
  <!-- bind your custom node type to a component by using slots, slot names are always `node-<type>` -->
  <template #node-special="specialNodeProps">
    <SpecialNode v-bind="specialNodeProps" />
  </template>

  <!-- bind your custom edge type to a component by using slots, slot names are always `edge-<type>` -->
  <template #edge-special="specialEdgeProps">
    <SpecialEdge v-bind="specialEdgeProps" />
  </template>
</VueFlow>

VueFlow component expects nodes and edges. Now that we understand the basics of how nodes and edges are configured, let’s review the VueFlow definition in the Canvas.vue:

<VueFlow
  :id="id"
  :nodes="vueFlowNodes"
  :edges="connections"
  :class="classes"
  :style="selectionBoxStyle"
  :apply-changes="false"
  :connection-line-options="{ markerEnd: MarkerType.ArrowClosed }"
  :connection-radius="60"
....

For one, this VueFlow component in n8n has a lot of props. You can see them in Canvas.vue L1771.

Below is a how Nodes are defined:

<template #node-canvas-node="nodeProps">
   <slot name="node" v-bind="{ nodeProps }">
    <Node
     v-bind="nodeProps"
     :data="nodeDataById[nodeProps.id]"
     :selected="nodeProps.selected && !fullySelectedGroupMemberIds.has(nodeProps.id)"
     :read-only="readOnly"
     :can-execute="canExecute"
     :event-bus="eventBus"
     :hovered="nodesHoveredById[nodeProps.id]"
...

I only copied a part of the entire component declaration and similarly edges are defined as shown below:

<template #edge-canvas-edge="edgeProps">
   <slot name="edge" v-bind="{ edgeProps, arrowHeadMarkerId }">
    <Edge
     v-bind="edgeProps"
     :marker-end="`url(#${arrowHeadMarkerId})`"
     :read-only="readOnly"
     :hovered="edgesHoveredById[edgeProps.id]"
     :bring-to-front="edgesBringToFrontById[edgeProps.id]"
     @add="onClickConnectionAdd"
     @delete="onDeleteConnection"
     @update:label:hovered="onUpdateEdgeLabelHovered(edgeProps.id, $event)"
    />
   </slot>
</template>

Nodes and Edges components are defined in the elements folder.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

concurrently usage in n8n codebase.

Ramu Narasinga — Mon, 24 Aug 2026 15:30:00 +0000

In this article, we review Concurrently. You will learn:

What is Concurrently?
Concurrently in n8n codebase.

What is Concurrently?

Run multiple commands concurrently. Like npm run watch-js & npm run watch-less but better.

The usual way to run multiple commands concurrently is npm run watch-js & npm run watch-css. That's fine but it's hard to keep on track of different outputs. Also if one process fails, others still keep running and you won't even notice the difference.

Features:

Cross platform (including Windows)
Output is easy to follow with prefixes
With --kill-others switch, all commands are killed if one dies

Learn more about concurrently.

Concurrently in n8n codebase.

I found concurrently in n8n codebase at packages/cli/package.json.

{
  "name": "n8n",
  "version": "2.36.0",
  "description": "n8n Workflow Automation Tool",
  "main": "dist/index",
  "types": "dist/index.d.ts",
  "scripts": {
  ...
  "dev": "concurrently -k -n \"TypeScript,Node\" -c \"yellow.bold,cyan.bold\" \"pnpm run watch\" \"nodemon --delay 1\"",
  }
}

Why concurrently? Like its explained above, concurrently provides outputs with prefixes when you have multiple scripts combined in a single script and is cross platform. I faced this issue in a project, on windows machine, where the dev script had & and as a result, it failed to run.

There are other scripts too where this concurrently is used in the same package.json file:

swift
...
"dev:worker": "concurrently -k -n \"TypeScript,Node\" -c \"yellow.bold,cyan.bold\" \"pnpm run watch\" \"nodemon worker\"",
"dev:webhook": "concurrently -k -n \"TypeScript,Node\" -c \"yellow.bold,cyan.bold\" \"pnpm run watch\" \"nodemon webhook\"",
...

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

useEditorContext composable in n8n codebase.

Ramu Narasinga — Fri, 21 Aug 2026 15:30:00 +0000

In this article, we review useEditorContext in n8n codebase. You will learn:

Composables in Vue
useEditorContext as composable in n8n.

Composables in Vue

In the context of Vue applications, a "composable" is a function that leverages Vue's Composition API to encapsulate and reuse stateful logic.

When building frontend applications, we often need to reuse logic for common tasks. For example, we may need to format dates in many places, so we extract a reusable function for that. This formatter function encapsulates stateless logic: it takes some input and immediately returns expected output. There are many libraries out there for reusing stateless logic - for example lodash and date-fns, which you may have heard of.

By contrast, stateful logic involves managing state that changes over time. A simple example would be tracking the current position of the mouse on a page. In real-world scenarios, it could also be more complex logic such as touch gestures or connection status to a database.

This is just like React Hooks.

Learn more about Composables.

useEditorContext as composable in n8n.

Now that we understand what a composable is in Vue.js, btw, n8n editor-ui is written in Vue, let's understand how useEditorContext is used.

Below is a comment I picked from useEditorContext.ts file.

/**
 * Per-editor host overrides for the current editor context.
 *
 * Editor hosts (e.g. the Instance AI artifact preview) scope their embedded
 * editor by providing `EditorEnabledFeaturesKey` - the capabilities the host
 * supersedes. AI features can only be restricted: an explicit `false` turns one
 * off, while omitted (or `true`) features fall back to their store values.
 * `readOnly` is a direct flag - `true` forces the canvas read-only. When no host
 * provides the key, AI features fall back to their store values and the canvas
 * is editable (`readOnly` is `false`).
 * `executionSuccessToasts` / `executionErrorToasts` are direct flags too - each
 * `true` (the default) shows that class of execution result toast; an explicit
 * `false` from the host suppresses it.
 */
export function useEditorContext() {

This comment explains what it does - Per-editor host overrides for the current editor context.

Below is the entire useEditorContext definition:

export function useEditorContext() {
 const settings = useSettingsStore();
 const enabledFeatures = inject(EditorEnabledFeaturesKey, null);

 // A host can only restrict: an explicit `false` supersedes the feature;
 // omitted (or `true`) falls back to the store gating below.
 const isEnabledByHost = (feature: EditorFeature): boolean =>
  enabledFeatures?.value?.[feature] !== false;

 const enabledInStore = (feature: EditorFeature): boolean => {
  switch (feature) {
   case 'aiAssistant':
    return settings.isAiAssistantEnabled === true;
   case 'aiBuilder':
    return settings.isAiBuilderEnabled === true;
   case 'askAi':
    return settings.isAskAiEnabled === true;
   case 'instanceAi':
    // Mirrors useInstanceAiAvailable() (the feature-layer gate) with
    // app-layer primitives so this base composable imports no feature:
    // the module is active, enabled, ready (or admin-fixable), and the
    // user may message Instance AI.
    return (
     settings.isModuleActive('instance-ai') &&
     settings.moduleSettings['instance-ai']?.enabled !== false &&
     (settings.moduleSettings['instance-ai']?.setupCompleted === true ||
      hasPermission(['rbac'], { rbac: { scope: 'instanceAi:manage' } })) &&
     hasPermission(['rbac'], { rbac: { scope: 'instanceAi:message' } })
    );
  }
 };

 const featureEnabled = (feature: EditorFeature) =>
  computed(() => enabledInStore(feature) && isEnabledByHost(feature));

 return {
  aiAssistant: featureEnabled('aiAssistant'),
  aiBuilder: featureEnabled('aiBuilder'),
  askAi: featureEnabled('askAi'),
  instanceAi: featureEnabled('instanceAi'),
  readOnly: computed(() => enabledFeatures?.value?.readOnly === true),
  expandGroups: computed(() => enabledFeatures?.value?.expandGroups),
  executionButtonType: computed(() => enabledFeatures?.value?.executionButtonType ?? 'primary'),
  executionSuccessToasts: computed(
   () => enabledFeatures?.value?.executionSuccessToasts !== false,
  ),
  executionErrorToasts: computed(() => enabledFeatures?.value?.executionErrorToasts !== false),
 };
}

This uses settings from useSettingsStore - Here Pinia is used. Pinia is a state management library.

I think this returns what features are enabled in the editor context, because this just returns an object containing features as keys and values being boolean depending on "feature enabled".

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

`generateNanoId` function in n8n codebase.

Ramu Narasinga — Wed, 19 Aug 2026 15:30:00 +0000

In this article, we review generate-nano-id.ts file. You will learn:

What is Nano ID?
How generateNanoId function is used?

What is Nano ID?

Nano ID is a tiny, secure, URL-friendly, unique string ID generator for JavaScript.

Features

Small. 118 bytes (minified and brotlied). No dependencies. Size Limit controls the size.
Fast. 50% faster than native crypto.randomUUID().
Safe. It uses hardware random generator. Can be used in clusters.
Short IDs. It uses a larger alphabet than UUID (A-Za-z0-9_-). So ID size was reduced from 36 to 21 symbols.
Portable. Nano ID was ported to over 20 programming languages..

Nano ID is built by Evil Martians, an American design and engineering consultancy for developer tools, AI, and cybersecurity startups.

How generateNanoId function is used?

In the n8n, when you click on Create workflow, you will get url that looks something like this — /workflow/V1StGXR8_Z5jdHi6B-myT.

Here the id is generated using generateNanoId, but this happens inside the beforeEnter method in the editor-ui/router.ts.

beforeEnter: (to) => {
   // Generate a unique workflow ID using 16-character nanoid and redirect to it
   // Preserve existing query params (e.g., templateId, projectId) and add new=true
   const newWorkflowId = generateNanoId();
   return {
    name: VIEWS.WORKFLOW,
    params: { workflowId: newWorkflowId },
    query: { ...to.query, new: 'true' },
   };
  },
 },

Technically when you click on Create workflow button in the workflows route, the code indicates that it redirects to /workflow/new but because of this check — beforeEnter, nanoId replaces the new with an actual nano id.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

warden.toml in Openwork codebase.

Ramu Narasinga — Wed, 12 Aug 2026 15:30:00 +0000

In this article, we review warden.toml in Openwork codebase. You will learn:

What is Warden?
Warden.toml file

What is Warden?

Warden watches over your code by running skills against your changes. Skills are Markdown prompts that define what to look for: security vulnerabilities, correctness bugs, API contract issues, performance problems, or anything else that needs consistent review coverage.

The important split:

warden.toml- Which skills run, which files they see, and how findings are reported.
GitHub workflow - When GitHub starts Warden and which credentials/action inputs are available.
Skill files - The review expertise Warden applies to changed code.

Every analysis run follows the same loop:

Identify what changed: files, hunks, directories, or an explicit git range.
Match changes against configured triggers.
Run the matching skills against the matching code.
Report findings with severity, location, and optional fixes.

Skills follow the agentskills.io specification. Warden includes security-review for baseline AppSec coverage and code-review for correctness bugs. Treat them as first passes, then add more skills when your codebase needs deeper coverage.

Learn more about Warden

Warden.toml file

We just found in the docs what this warden.toml file is about. It defines

Which skills to run?
Which files they see?
How findings are reported?

Openwork's warden.toml file

Below is the code i picked from openwork/warden.toml file

version = 1

# Warden gates clearance on blocking findings from two skills:
# diff-security-review (all findings block) and desktop-den-sync-review (only
# high findings block; medium findings are advisory). The clearance itself is
# granted by .github/workflows/warden-clearance.yml.

[defaults]
reportOn = "low"
ignorePaths = [
  "**/node_modules/**",
  "**/pnpm-lock.yaml",
  "**/dist/**",
  "**/*.min.js",
]

[defaults.agent]
model = "openai/gpt-5.6-luna"

# Auxiliary verifies/merges findings and gates what survives to the report;
# keep it on the same strong model so weak verification can't cause a false
# clearance.
[defaults.auxiliary]
model = "openai/gpt-5.6-luna"

[[skills]]
name = "diff-security-review"

[[skills.triggers]]
type = "pull_request"
actions = ["opened", "synchronize", "reopened"]
draft = false

# Lets developers run `warden` locally on uncommitted changes before pushing.
[[skills.triggers]]
type = "local"

[[skills]]
name = "desktop-den-sync-review"
paths = [
  "apps/app/**",
  "apps/desktop/**",
  "ee/apps/den-api/**",
  "packages/types/**",
]

[[skills.triggers]]
type = "pull_request"
actions = ["opened", "synchronize", "reopened"]
draft = false

[[skills.triggers]]
type = "local"

Warden can be run in Github Actions context and you can find how Openwork defined their warden configuration at openwork/.github/warden.yaml

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

openwork, the open-source alternative to Claude Cowork.

Ramu Narasinga — Tue, 11 Aug 2026 15:30:00 +0000

In this article, we review Openwork. You will learn:

What is Openwork?
Features

What is Openwork?

OpenWork is a free, open-source desktop app made for sharing AI workflows. It is an open-source alternative to Claude Cowork and Codex for macOS, Windows, and Linux.

Add one OpenWork MCP to Codex, Claude Code, Cursor, or another compatible agent and reuse the same skills, MCPs, and connected services across your tools, teammates, and machines. Create something once, share it with coworkers or friends, or keep it for yourself.

The desktop app is there when you want a dedicated workspace, but it is not required. You can use OpenWork from the agent you already have. For larger organizations, the admin interface lets you publish capabilities, manage access, and configure shared or per-user connections.

You can download Openwork here

Features

Chat on your files and tools
Claude and models
GPT-5, Gemini, Mistral, and local models
Browser automation
MCP gateway

and much more

I checked the docs for the browser automation and these are my findings:

How to use OpenWork to automate the built-in browser?

Computer-use in OpenWork currently works through the built-in OpenWork Browser. It does not yet mean full desktop control of Ubuntu, macOS, or Windows apps.OpenWork can open pages, click, fill forms, read page content, and take screenshots inside that browser. If you connect to a remote OpenWork server, the browser runs on that remote worker.Today, the supported path is the first-party OpenWork Browser extension.

Learn more about Browser Automation.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Voicebox, the open-source AI voice studio.

Ramu Narasinga — Mon, 10 Aug 2026 15:30:00 +0000

In this article, we review Voicebox. You will learn:

What is Voicebox?

What is Voicebox?

I found the Voicebox trending this week on Github. I got the below definition from their README.

Voicebox is a local-first AI voice studio - a free and open-source alternative to ElevenLabs and WisprFlow in one app. Clone voices from a few seconds of audio, generate speech in 23 languages across 7 TTS engines, dictate into any text field with a global hotkey, and give any MCP-aware AI agent a voice of your choosing.

The two cloud incumbents sit on opposite halves of the voice I/O loop - ElevenLabs on output, WisprFlow on input. Voicebox does both, bridges them with a bundled local LLM for refinement and per-profile personas, and runs the whole thing on your machine.

Complete privacy - models, voice data, and captures never leave your machine
7 TTS engines - Qwen3-TTS, Qwen CustomVoice, LuxTTS, Chatterbox Multilingual, Chatterbox Turbo, HumeAI TADA, and Kokoro
Voice cloning and preset voices - zero-shot cloning from a reference sample, or 50+ curated preset voices via Kokoro and Qwen CustomVoice
23 languages - from English to Arabic, Japanese, Hindi, Swahili, and more
Post-processing effects - pitch shift, reverb, delay, chorus, compression, and filters
Expressive speech - paralinguistic tags like [laugh], [sigh], [gasp] via Chatterbox Turbo; natural-language delivery control via Qwen CustomVoice
Unlimited length - auto-chunking with crossfade for scripts, articles, and chapters
Stories editor - multi-track timeline for conversations, podcasts, and narratives
Voice input - global dictation hotkey with push-to-talk and toggle modes, accessibility-verified auto-paste on macOS, in-app mic on every text field, Whisper-based STT
Agent voice output - one tool call (voicebox.speak) and any MCP-aware agent (Claude Code, Cursor, Cline) speaks to you in a voice you've cloned
Voice personalities - attach a free-form persona to any voice profile, then Compose, Rewrite, or Respond via a bundled local LLM - agents can invoke the same modes over MCP
API-first - REST API plus a built-in MCP server for integrating voice I/O into your own apps and agents
Native performance - built with Tauri (Rust), not Electron
Runs everywhere - macOS (MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, Docker

Features

Multi-Engine Voice Cloning
Emotion and Paralinguistic Tags
Post-Processing Effects
Unlimited Generation Length
Generation versions
Async Generation Queue
Voice Profile Management
Stories Editor
Global Dictation and Voice Input
Speech-to-text

I recommend to checkout Voicebox README, to get a comprehensive list of features supported.

API

The following API examples were provided in the README.

# Generate speech
curl -X POST http://127.0.0.1:17493/generate \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world", "profile_id": "abc123", "language": "en"}'

# Agent voice output - any app or script can speak in a cloned voice
curl -X POST http://127.0.0.1:17493/speak \
  -H "Content-Type: application/json" \
  -H "X-Voicebox-Client-Id: my-script" \
  -d '{"text": "Deploy complete.", "profile": "Morgan"}'

# Transcribe an audio file
curl -X POST http://127.0.0.1:17493/transcribe \
  -F "audio=@recording.wav" \
  -F "model=whisper-turbo"

# List voice profiles
curl http://127.0.0.1:17493/profiles

Is it free? yes, atm. Voicebox mentioned cloud based pricing is coming soon, at the time of writing this article.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

TencentDB Agent Memory, a team-level memory hub for AI Agents.

Ramu Narasinga — Mon, 03 Aug 2026 15:30:00 +0000

In this article, we review TencentDB Agent Memory. You will learn:

What is TencentDB Agent Memory?
How is Agent Memory implemented?

What is TencentDB Agent Memory?

TencentDB Agent Memory authors started from a practical question: How do you reduce repetitive work when using Agents?

If project context has already been explained, it shouldn't need to be repeated in a new session. If documents have already been read, every Agent shouldn't have to start again from page one. A workflow that already works shouldn't have to be rediscovered next time.

Memory here means more than just "remembering conversations." Any information that helps the next Agent avoid reinventing the wheel should be saved, organized, and reused.

Existing information → Reusable memory assets → Fewer turns → Less rework → More stable results and higher efficiency

I recommend reading these sections from the Github README:

How is Agent Memory implemented?

I found this technical implementation in the README.. TencentDB Agent Memory doesn't aim to "store everything." It solves three problems: what's worth keeping, who can use it, and how to retrieve less while retrieving the right things next time.

These below sections are defined:

Memory isn't flat records - it grows in layers

Memory isn't a global prompt - it's the Agent's loadout
Knowledge isn't injected wholesale - it's called on demand

Benchmarking is done using Personamem. Learn more about PersonaMem

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Alchemy, an Infrastructure-as-Effects framework.

Ramu Narasinga — Tue, 28 Jul 2026 15:30:00 +0000

In this article, we review Alchemy. You will learn:

What is Alchemy?
alchemy.run.ts file in OSS projects.

What is Alchemy?

Well, before we jump into its definition, let me explain how I found in the open source projects. I came across the file named alchemy.run.ts in t3code.. This got me google Alchemy and found this site — https://alchemy.run/.

Alchemy is an Infrastructure-as-Effects framework. It extends Infrastructure-as-Code by combining your cloud resources and the application logic that uses them into a single, type-safe program powered by Effects.

Learn more about Alchemy.

Quick start guide:

Create a project

mkdir my-app && cd my-app && bun init -y

Install dependencies

bun add "alchemy@next" "effect@>=4.0.0-beta.100 || >=4.0.0" "@effect/platform-bun@>=4.0.0-beta.100 || >=4.0.0" "@effect/platform-node@>=4.0.0-beta.100 || >=4.0.0"

Create your stack — in the file, alchemy.run.ts

import * as Alchemy from "alchemy";
import * as Cloudflare from "alchemy/Cloudflare";
import * as Effect from "effect/Effect";

export default Alchemy.Stack(
  "MyApp",
  {
    providers: Cloudflare.providers(),
    state: Cloudflare.state(),
  },
  Effect.gen(function* () {
    const bucket = yield* Cloudflare.R2.Bucket("Bucket");

    return {
      bucketName: bucket.bucketName,
    };
  }),
);

Deploy — Run alchemy deploy to create the Bucket on Cloudflare

I got these instructions from the Getting Started docs.

alchemy.run.ts file in OSS projects.

You define your stack in alchemy.run.ts, you have to remember this from the Getting Started guide.

t3code/infra/relay/alchemy.run.ts

You will find the below code in t3code/infra/../alchemy.run.ts

// @effect-diagnostics anyUnknownInErrorContext:off layerMergeAllWithDependencies:off - Alchemy provider helpers expose framework-owned any requirements.
import * as Alchemy from "alchemy";
import * as Axiom from "alchemy/Axiom";
import * as Cloudflare from "alchemy/Cloudflare";
import * as Drizzle from "alchemy/Drizzle";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Planetscale from "alchemy/Planetscale";

import * as RelayDb from "./src/db.ts";
import { RelayObservability } from "./src/observability.ts";
import { ManagedEndpointZone, RelayApiZone } from "./src/zone.ts";
import ApiLive, { Api } from "./src/worker.ts";

export default Alchemy.Stack(
  "T3CodeRelay",
  {
    providers: Layer.mergeAll(
      Axiom.providers(),
      Cloudflare.providers(),
      Drizzle.providers(),
      Planetscale.providers(),
    ),
    state: Cloudflare.state(),
  },
  Effect.gen(function* () {
    const db = yield* RelayDb.PlanetscaleDatabase;
    const hyperdrive = yield* RelayDb.RelayHyperdrive;
    const managedEndpointZone = yield* ManagedEndpointZone.pipe(Effect.orDie);
    const relayApiZone = yield* RelayApiZone.pipe(Effect.orDie);
    const observability = yield* RelayObservability;
    const api = yield* Api;

    return {
      databaseName: db.database.name,
      databaseBranchName: db.branch?.name ?? "main",
      hyperdriveName: hyperdrive.name,
      workerName: api.workerName,
      url: api.url,
      relayApiZoneId: relayApiZone.zoneId,
      managedEndpointZoneId: managedEndpointZone.zoneId,
      mobileTracingUrl: observability.traces.otelTracesEndpoint,
      mobileTracingDataset: observability.traces.name,
      mobileTracingToken: observability.mobileIngestToken.token,
      clientTracingUrl: observability.traces.otelTracesEndpoint,
      clientTracingDataset: observability.traces.name,
      clientTracingToken: observability.clientIngestToken.token,
    };
  }).pipe(Effect.provide(ApiLive)),
);

open-seo/alchemy.run.ts

This open-seo/alchemy.run.ts has about 310 LOC at the time of writing this article. Below I copied the important code snippet:

export default Alchemy.Stack(
  "open-seo",
  {
    providers: Cloudflare.providers(),
    // Durable state in the Cloudflare state store (an `alchemy-state-store`
    // Worker on this account; one-time `pnpm alchemy cloudflare bootstrap`).
    // CI fetches its auth token from the account Secrets Store each run.
    state: Cloudflare.state(),
  },
  Effect.gen(function* () {
    const stage = yield* Alchemy.Stage;
    const prod = stage === HOSTED_PROD_STAGE;
    // Fail closed: an unset AUTH_MODE gets the Access-gated mode (matching the
    // app's own default in src/lib/auth-mode.ts), never public hosted signup.
    // hosted/local_noauth must be set explicitly.
    const authMode = yield* Config.string("AUTH_MODE").pipe(
      Config.withDefault("cloudflare_access"),
    );
    const databaseProvider = yield* optionalVar("DATABASE_PROVIDER");
    const workersSubdomain = yield* readWorkersSubdomain({ required: false });

    // Auth needs an absolute BETTER_AUTH_URL. Prod sets it explicitly;
    // previews always derive it from the deterministic worker name — a wrong
    // WORKERS_SUBDOMAIN surfaces in CI's post-deploy Access verify step.
    let authUrl: string;
    if (prod) {
      authUrl = yield* optionalVar("BETTER_AUTH_URL");
      if (!authUrl) {
        return yield* Effect.die(
          new Error(
            "Set BETTER_AUTH_URL (https://app.openseo.so) in .env.production.",
          ),
        );
      }
      // Prod must say which database it runs on. A silently-defaulted "d1"
      // would deploy cleanly against the stale pre-Postgres data.
      if (databaseProvider !== "postgres" && databaseProvider !== "d1") {
        return yield* Effect.die(
          new Error(
            "Set DATABASE_PROVIDER explicitly in .env.production (prod runs postgres).",
          ),
        );
      }
    } else if (workersSubdomain) {
      authUrl = `https://${workerName(stage)}.${workersSubdomain}`;
    } else if (authMode === "hosted") {
      return yield* Effect.die(
        new Error(
          "Hosted previews derive BETTER_AUTH_URL from WORKERS_SUBDOMAIN — set it to the account's full workers.dev subdomain (shown under Workers & Pages).",
        ),
      );
    } else {
      // local_noauth / cloudflare_access never read BETTER_AUTH_URL —
      // src/lib/auth.ts uses a placeholder baseURL off the hosted path.
      authUrl = "";
    }

    // cloudflare_access self-host reads these; hosted/local_noauth leave them
    // empty. (Deriving/provisioning the Access application is a follow-up PR.)
    const teamDomain = yield* optionalVar("TEAM_DOMAIN");
    const policyAud = yield* optionalVar("POLICY_AUD");

    const app = yield* Cloudflare.Worker("open-seo", {
      name: workerName(stage),
      // Prod serves the real domains; the zone is inferred from the hostname.
      domain: prod ? ["app.openseo.so", "www.app.openseo.so"] : undefined,
      // Prebuilt worker from `vite build` (@cloudflare/vite-plugin). The entry
      // exports the DO + WorkflowEntrypoint classes (re-exported by
      // src/server.ts), which `bundle: false` requires. Sibling chunks under
      // assets/ are uploaded as-is by the default module rules.
      main: "./dist/server/index.js",
      bundle: false,
      assets: {
        directory: "./dist/client",
      },
      compatibility: {
        date: wrangler.compatibility_date,
        flags: wrangler.compatibility_flags,
      },
      // Site audits parse and persist batches of HTML inside Workflow steps.
      // Paid Workers permit up to five minutes; keep headroom for unusually
      // link-heavy sites after bounding page bodies and bulk-writing links.
      limits: { cpuMs: 300_000 },
      observability: {
        enabled: wrangler.observability?.enabled ?? true,
        traces: { enabled: wrangler.observability?.traces?.enabled ?? false },
      },
      placement:
        wrangler.placement?.mode === "smart" ? { mode: "smart" } : undefined,
      // Scheduled rank checks — src/server.ts `scheduled` handler.
      crons: wrangler.triggers.crons,
      env: {
        ...makeResources(stage),
        ...dataEnv,
        AUTH_MODE: authMode,
        DATABASE_PROVIDER: databaseProvider || "d1",
        BETTER_AUTH_URL: authUrl,
        TEAM_DOMAIN: teamDomain,
        POLICY_AUD: policyAud,

        // Prod-only: pooled Postgres via the existing Hyperdrive config.
        ...(prod ? { HYPERDRIVE: makeHyperdrive() } : {}),

        // Durable Objects (Agents SDK chat agents). Alchemy backs new DO
        // classes with SQLite storage, which both require.
        ...Object.fromEntries(
          wrangler.durable_objects.bindings.map((binding) => [
            binding.name,
            Cloudflare.DurableObject(binding.name, {
              className: binding.class_name,
            }),
          ]),
        ),

        // Cloudflare Workflows (upstream props-only form for prebuilt
        // workers). Workflow names are ACCOUNT-scoped: prod owns the
        // unsuffixed names; previews carry the stage suffix so concurrent
        // stages can't repoint each other's workflows (registration is a
        // PUT-as-upsert on the name).
        ...Object.fromEntries(
          wrangler.workflows.map((workflow) => [
            workflow.binding,
            Cloudflare.Workflow(
              prod ? workflow.name : `${workflow.name}-${stage}`,
              { className: workflow.class_name },
            ),
          ]),
        ),
      },
    }).pipe(
      // Prod adopts the live worker serving app.openseo.so; never delete it
      // on destroy. (Workflow registrations aren't individually retainable —
      // they're created inside the worker provider — but re-registering them
      // is a lossless upsert, unlike deleting the data-bearing resources.)
      Alchemy.RemovalPolicy.retain(prod),
    );

    return { url: app.url.as<string>() };
  }),

Tbh, I do not completely understand this stack setup using Cloudflare. Doing some simple project deployments on cloudflare should help you understand the concepts better.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Browser Use, Make websites accessible for AI agents.

Ramu Narasinga — Fri, 10 Jul 2026 15:30:00 +0000

In this article, we review Browser Use. You will learn:

What is Browser Use
Quickstart guide

What is Browser Use

Browser Use is a Python library for AI browser automation with 104k+ GitHub stars. Connect any LLM and run locally or self-hosted.

I came across the Browser Use when I was checking out the Page Agent.

When you sign up on Browser Use, you will see the above screen. To give it a shot, since a new user get 10 free tasks, I wrote the following prompt and submitted:

Find the cheapest flight from London to Vancouver

It ran for some time and gave this result.

You will find two tabs on the right:

Browser
Files

The one I opened is an output produced at the end of the conversation. But this is just one example.

Use cases

I found more examples in their Github README such as:

Open those links, you will find demo videos, demonstrating how powerful browser use is.

Quickstart guide

If you want to use Browser Use in your agent (Claude Code, Codex, Cursor, Hermes, OpenClaw, etc.), paste this prompt, and it sets everything up itself:

Install or upgrade browser-use to the latest stable version with uv using Python 3.12, run `browser-use skill install` to register the skill, and connect it to my browser. If setup or connection fails, follow https://github.com/browser-use/browser-harness/blob/main/install.md.

Then tell your agent what you want done.

Python library: the easiest way to automate the web

Want to automate the web at scale, from your own code, and with any LLM? Use the Python library:

Install Browser Use (Python >= 3.11):

uv add browser-use
# or: pip install browser-use

Add your LLM API key to .env. Get one from Browser Use Cloud, or bring your own provider key:

# .env
BROWSER_USE_API_KEY=your-key
# GOOGLE_API_KEY=your-key
# ANTHROPIC_API_KEY=your-key

Run your first agent:

import asyncio

from browser_use import Agent, ChatBrowserUse

async def main():
    agent = Agent(
        task="Find the number of stars of the browser-use repo",
        llm=ChatBrowserUse(model='openai/gpt-5.5'),
        # llm=ChatBrowserUse(model='bu-2-0'),  # Browser Use's optimized model
        # llm=ChatOpenAI(model='gpt-5.5'),
        # llm=ChatAnthropic(model='claude-opus-4-8'),  # Sonnet also works well
    )
    history = await agent.run()

if __name__ == "__main__":
    asyncio.run(main())

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com