Forem: Ashita

Agent Watch:Stop Telling Your AI Agent the Same Thing Twice! ✋

Ashita — Sun, 15 Feb 2026 21:15:45 +0000

This is a group submission for the GitHub Copilot CLI Challenge

Introduction

"Auto-sync your AI instructions with every commit using agent-watch", a git hook that reads your commits and conversations, then uses AI to keep all your agent instruction files current — so your AI tools always know what your codebase looks like today.

Demo

What We Built

AI coding assistants like Claude Code, GitHub Copilot, Cursor, Windsurf and Cline, each read an instruction file(CLAUDE.md, .cursorrules, copilot-instructions.md, etc.) to understand your project's conventions, architecture, and rules.
But here's the thing: Your codebase changes every day. Those instruction files don't.

You could refactor a module, swap a library or change an API pattern, yet your AI agent is still giving advice based on stale instructions. You are either manually updating those files (tedious) or you don't (getting worse AI suggestions over time).

What Agent Watch Does

It plugs into your git workflow and automatically updates your AI instruction files after every commit or push. No manual effort.

Here's the flow:

Git hook fires - on commit or push, agent-watch run is triggered automatically.
Smart filter checks - skips entirely if only docs, configs, or lock files changed.
Sessions extracted - pulls latest 3 unprocessed sessions from Claude Code, Copilot Chat, and Copilot CLI.
Patterns summarized - Copilot CLI distills each session into actionable conventions.
Atomic update - a single copilot --yolo command updates all agent files at once with combined context

That's it. Your AI tools always have fresh, accurate instructions.

What This Means for You as a Developer

Your AI assistants get smarter over time — they learn as your codebase evolves, not just when you remember to update a config file
Zero maintenance overhead — you never touch those instruction files manually again.
Works with whatever AI tool you use — one tool keeps Claude, Copilot, Cursor, Windsurf, and Cline all in sync.
Doesn't slow you down — smart filtering skips running when you only change docs, lock files, or configs.
Fits your existing workflow — supports Lefthook, Husky, or plain git hooks. Just agent-watch init and forget about it.

The Bigger Picture

AI coding assistants are only as good as the context they have. Agent Watch closes the gap between what your codebase actually looks like and what your AI tools think it looks like. It turns static instruction files into living documents that evolve with your code.

It's a small tool that solves a real, growing pain point — and as AI-assisted development becomes the norm, keeping agent context fresh isn't optional anymore. It's table stakes.

How GitHub Copilot CLI is leveraged for this tool

Agent Watch doesn't contain any AI logic itself. It's purely plumbing — git hooks, file detection, context gathering, and state tracking. All the intelligence is delegated to GitHub Copilot CLI. Every time Agent Watch needs to summarize sessions, understand code patterns, or update agent files, it shells out to Copilot CLI with a carefully crafted prompt. The final update uses a single copilot --yolo command that reads and updates all agent files atomically in one pass. Copilot CLI is the brain; Agent Watch is the nervous system that triggers it at the right time with the right context.

3 Distinct Uses of Copilot CLI

1) Creating Missing Agent Files
During agent-watch init, if a selected agent file doesn't exist, Copilot CLI analyzes your codebase and generates a tailored starting file.

2) Updating Agent Files on Every Commit
The core use. On each git hook trigger, Agent Watch gathers context (commit message, changed files, diff stats, chat sessions) and asks Copilot CLI to intelligently merge new patterns into each managed agent file — or skip if nothing meaningful changed.

3) Extracting Chat Session History
Agent Watch discovers your past Copilot conversations, filters to the current project, and asks Copilot CLI to summarize them. These insights feed into the agent file updates above.

Get Started

1.Installation

Global installation(Highly Recommended)

npm install -g agent-watch

As a dev dependency

npm install -D agent-watch


 # or


pnpm add -D agent-watch

Run directly without installation:

npx agent-watch init

2. Initialize your project

cd your-project
agent-watch init

Before vs. After using agent-watch

Before agent-watch:-

You're building a Node.js backend. Over the course of a sprint:

Monday: You set up Express with a centralized error handler middleware.
Tuesday: You adopt Drizzle ORM and write all queries through a repository pattern
Wednesday: You add JWT auth with refresh tokens and role-based access
Thursday: A teammate asks Cursor to write a new endpoint — it uses raw SQL, try/catch in every route, and rolls its own auth check

⛔PROBLEM⛔: Your AI agent files are stuck in the past. Every assistant on the team is guessing instead of following what you've already established.

After agent-watch:-

Every commit automatically updates your agent instruction files:

Monday commit: "Use centralized error handler — never catch errors in individual routes"
Tuesday commit: "Use Drizzle ORM with repository pattern — no raw SQL"
Wednesday commit: "Auth uses JWT with refresh tokens — use requireRole() middleware"
Thursday commit: Teammate's Cursor already knows all of this. It generates the endpoint correctly on the first try.

RESULT: Conventions are captured as they emerge, not weeks later when someone remembers to update a config file. Every AI assistant on your team stays aligned — automatically. ✅

Challenges Faced(and how Copilot CLI helped)

Git hooks without breaking existing setups
Teams use Lefthook, Husky, or raw hooks. Copilot CLI helped us design marker-based injection that works alongside any existing setup and is safe to re-run.
Discovering chat sessions across three AI tools
Claude Code, Copilot Chat, and Copilot CLI all store sessions in different locations and formats. We use Copilot CLI to summarize sessions from all three into a unified format.
Combining everything into one coherent update
Sessions could easily produce noisy, duplicate updates.copilot --yolo command takes all summaries and file paths, then updates every agent file automically in one pass.

The Takeaway: Agent Watch is plumbing. Every intelligent decision is a Copilot CLI call at the right moment with the right context.

Repository

surnr / agent-watch

CLI tool that uses git hooks to keep your AI agent configuration files in sync with your codebase

Agent Watch

Keep your AI agents in sync with your evolving codebase—automatically.

Agent Watch is a CLI tool that captures knowledge from your development workflow—git commits, code changes, and AI chat sessions—and intelligently updates your AI agent configuration files. Stop manually copying patterns from chat sessions. Stop forgetting to update CLAUDE.md or Copilot instructions. Let agent-watch learn from your work and keep your AI agents informed.

Why Agent Watch?

The Problem

You're having productive conversations with Claude Code, GitHub Copilot, and other AI assistants. They help you establish patterns, conventions, and best practices. But this knowledge stays trapped in chat history. Your agent configuration files (CLAUDE.md, copilot-instructions.md, etc.) become outdated within days.

Result: Your AI assistants keep making the same mistakes. They forget your team's conventions. You waste time repeating yourself.

The Solution

Agent Watch automatically:

✅ Extracts patterns from your Claude Code, Copilot Chat, and Copilot CLI sessions
✅…

View on GitHub

Package

agent-watch

Contributors

@itsashita x @surnr

From Spaghetti Code to Orchestrated Workflows: Building AyurAI with Motia & Mux

Ashita — Mon, 05 Jan 2026 07:49:59 +0000

This is a submission for the DEV's Worldwide Show and Tell Challenge Presented by Mux

What I Built

AyurAI is a comprehensive AI-powered Ayurvedic wellness platform that democratizes access to holistic healthcare. The platform seamlessly integrates three core pillars:

1. AI Voice Assistant

Users can engage in natural, conversational exchanges with an intelligent wellness advisor powered by VAPI. Available 24/7, the assistant provides personalized Ayurvedic guidance without the barrier of cost or availability. It's trained to provide authentic Ayurvedic advice while being accessible to modern users.

2. Practitioner Appointment System

A complete booking and management system that connects users with certified Ayurvedic doctors. Users can:

View available practitioners and their schedules
Book appointments with conflict detection
Receive confirmation emails automatically
Track their consultation history
Manage upcoming appointments

The system handles complex scenarios like preventing double-bookings, checking doctor availability, and automatically notifying both patient and practitioner.

3. Educational Video Library

A curated collection of Ayurvedic wellness videos with professional streaming capabilities. Users can:

Browse wellness content
Stream videos with adaptive quality
Resume from where they left off
Autogenerated thumbnail by Mux

This isn't just video hosting—it's a complete learning journey with progress tracking and a personalized experience.

Additional Features

User Dashboard - Wellness journey overview, completed visits tracking, upcoming appointments
Admin Dashboard - Doctor management, video uploads, appointment analytics, performance metrics
Dark Mode UI - Optimized for comfortable viewing

Project Structure

https://github.com/devandop/ayur-ai

ayurai/
├── src/
│   ├── app/                    # Next.js App Router
│   │   ├── dashboard/          # User dashboard + video library
│   │   ├── admin/              # Admin dashboard
│   │   ├── appointments/       # Booking system
│   │   └── voice/              # AI assistant
│   ├── components/
│   │   ├── ui/                 # Radix + shadcn components
│   │   ├── dashboard/          # Dashboard components
│   │   └── admin/              # Admin components
│   ├── hooks/                  # React Query hooks
│   └── lib/actions/            # Server actions
│
├── backend/
│   ├── src/api/                # Motia workflow steps
│   │   ├── create-appointment.step.ts
│   │   ├── admin-add-video.step.ts
│   │   └── ...
│   └── src/events/             # Event handlers
│
└── prisma/schema.prisma        # Database schema

Running Locally

# Frontend
npm install
npm run dev

# Backend (separate terminal)
cd backend
npm install
npm run dev

Required environment variables: DATABASE_URL, CLERK_SECRET_KEY, MUX_TOKEN_ID, MUX_TOKEN_SECRET

The Story Behind It

The Inspiration

Ayurveda has guided millions toward wellness for over 5,000 years. It's a sophisticated medical system that views health holistically—not as the absence of disease, but as a state of balance in body, mind, and consciousness.

Yet here we are in 2025, and accessing Ayurvedic wisdom remains surprisingly difficult:

The Pain Points:

Scarcity - Qualified Ayurvedic practitioners are rare and concentrated in certain regions
Cost - Consultations are expensive, often unaffordable for the average person
Inconvenience - Scheduling requires travel, time off work, and planning
Fragmentation - Knowledge is scattered across books, blogs, and individual practitioners
Impermanence - Guidance comes and goes—there's no continuous journey tracking

I wanted to solve this. Not by replacing traditional Ayurveda, but by making it accessible.

The Realization

I noticed that successful health platforms share a pattern:

Instant Access - Users get help immediately (not days later)
Professional Backup - AI is great, but human expertise matters
Education - Users learn and take ownership of their health
Continuity - Progress is tracked and visible over time

AyurAI combines all four.

Technical Highlights

The Challenge: Building a Robust Backend

Traditional backend architecture would require:

Routes → Controllers → Services → Database
↓
Manual event handling
↓
Complex error recovery
↓
Tightly coupled code

The Solution: Event-Driven Workflows with Motia

Isolated Workflow Steps
↓
Declarative Event Emission
↓
Automatic Event Orchestration
↓
Self-Documenting Code

Why Motia Was The Right Choice

1. Declarative, Self-Documenting Workflows

Instead of buried business logic, each workflow is clear and explicit:

export const config: ApiRouteConfig = {
  type: 'api',
  name: 'CreateAppointment',
  path: '/api/appointments',
  method: 'POST',
  emits: ['appointment.created'],        // ← Clear what this produces
  flows: ['appointment-management'],      // ← Declares the flow it belongs to
  middleware: [
    errorHandlerMiddleware,              // ← Built-in error handling
    clerkAuthMiddleware,                 // ← Authentication
    RateLimiters.moderate,               // ← Rate limiting
    SanitizationPresets.medicalNotes,   // ← Input sanitization
  ],
}

Anyone reading this knows exactly what the step does, what security is applied, and what events it produces.

2. Event-Driven Orchestration

When an appointment is created, instead of manually writing callback chains:

// With Motia - it's just one line:
await ctx.emit({
  topic: 'appointment.created',
  data: {
    appointmentId: appointment.id,
    patientEmail: appointment.user.email,
    doctorName: appointment.doctor.name,
    date: appointment.date,
    time: appointment.time,
  }
})

Motia automatically triggers:

Email notifications (via separate event handler)
Analytics tracking (via separate event handler)
Notification caching (via separate event handler)
Any future handlers we add (no code changes needed)

Zero manual coordination.

3. Built-in Middleware Stack

Motia provides production-grade middleware out of the box:

Authentication Middleware:

export const clerkAuthMiddleware: ApiMiddleware = async (req, ctx, next) => {
  const clerkUserId = req.headers['x-clerk-user-id']

  const user = await prisma.user.upsert({
    where: { clerkId: clerkUserId },
    update: { email, firstName, lastName },
    create: { clerkId: clerkUserId, email, firstName, lastName }
  })

  ;(ctx as any).user = user
  return await next()
}

Rate Limiting:

const rateLimiter = createRateLimiter({
  maxRequests: 30,
  windowSeconds: 60,
  keyExtractor: (req, ctx) => {
    const user = (ctx as any).user
    return user?.id || 'anonymous'
  }
})

Input Sanitization:

const sanitizeString = (str: string, options = {}) => {
  if (typeof str !== 'string') return str
  let sanitized = removeControlCharacters(str)
  sanitized = trimAndLimit(sanitized, options.maxLength || 1000)
  sanitized = options.stripHTML ? stripHTML(sanitized) : sanitizeHTML(sanitized)
  return sanitized
}

These are applied consistently across all workflows.

4. Type-Safe Event Handling

Events are typed and validated using Zod:

const responseSchema = z.object({
  id: z.string(),
  date: z.string(),
  status: z.enum(['CONFIRMED', 'COMPLETED', 'CANCELLED']),
  notes: z.string().nullable(),
  // ... more fields
})

export const config = {
  responseSchema: {
    200: responseSchema,
    401: z.object({ error: z.string() }),
    500: z.object({ error: z.string() }),
  }
}

If a response doesn't match the schema, it fails loudly. This catches bugs before they hit production.

5. Scalability Through Event Queuing

Using BullMQ under the hood, events are queued and processed reliably:

Event Emission
    ↓
BullMQ Queue
    ↓
Event Processors
    ↓
Database Updates / Emails / Analytics

If an event handler fails, it automatically retries with exponential backoff.

6. Visual Debugging with Motia Workbench

The Motia Workbench provides a visual interface showing:

All workflow steps and their connections
Real-time event flows
Failed workflows with stack traces
Performance metrics
Request/response logs

Instead of blindly searching through logs, you can see exactly what happened.

Real-World Example: Appointment Booking Flow

Here's how AyurAI handles a complete appointment booking:

1. User submits appointment form
   ↓
2. POST /api/appointments hits CreateAppointment step
   ↓
3. Validation layer (Zod schema)
   ↓
4. Auth middleware (verify user)
   ↓
5. Rate limiting (max 30 bookings/minute)
   ↓
6. Sanitization (clean user input)
   ↓
7. Database checks:
   - Doctor exists and is active?
   - Time slot available?
   - User doesn't have conflict?
   ↓
8. Create appointment record
   ↓
9. Emit 'appointment.created' event
   ↓
10. Motia automatically triggers:
    ├─ Email to user (confirmation)
    ├─ Email to doctor (new appointment)
    ├─ Analytics tracking (appointment created)
    └─ Cache invalidation (user appointments cache)
   ↓
11. Return success to frontend
    ↓
12. Frontend optimistically updates UI
    ↓
13. TanStack Query refetches and syncs

Not a single line of manual coordination code.

Comparison: Motia vs Traditional Express

Aspect	Express	Motia
Boilerplate	Manual routes, controllers, services	Declarative steps
Events	Manual pub/sub setup	Built-in, automatic orchestration
Middleware	Write custom, apply manually	Built-in, composable
Error Handling	Write catch/finally blocks	Automatic retry logic
Scaling	Manage queues manually	BullMQ integrated
Documentation	Separate OpenAPI specs	Self-documenting config
Testing	Spy on internals	Test steps independently
Debugging	Log diving	Visual workflow tracing

Use of Mux (Additional Prize Category Participants Only)

Most platforms use Mux only for video hosting. AyurAI goes much deeper.

1. Direct Upload Infrastructure

Instead of uploading videos to my server (which is slow and storage-intensive), admins upload directly to Mux:

// Step 1: Create upload URL
const upload = await mux.video.uploads.create({
  new_asset_settings: {
    playback_policy: ['public'],
  },
})

// Returns: { id, url }
// Admin uploads to this URL directly
// Video never touches my servers

Benefits:

Server bandwidth savings
Faster uploads
No storage costs
Secure direct transfer

2. Automatic Asset Processing

Once uploaded, Mux automatically:

Encoding:

Converts to VP9, H.264, H.265
Multiple quality levels (720p, 1080p, 4K)
Generates HLS and DASH streams

Thumbnail Generation:

Extracts key frames
Generates optimized thumbnails
Available at: https://image.mux.com/{playbackId}/thumbnail.jpg

// AyurAI automatically stores this URL
const video = await prisma.video.create({
  data: {
    title,
    description,
    muxAssetId: asset.id,
    muxPlaybackId: asset.playback_ids[0].id,
    thumbnailUrl: `https://image.mux.com/${asset.playback_ids[0].id}/thumbnail.jpg`,
    duration: asset.duration,
  }
})

3. Adaptive Bitrate Streaming

Mux serves the appropriate quality based on user's connection:

// All video URLs are HLS streams
<video
  src={`https://stream.mux.com/${muxPlaybackId}.m3u8`}
  controls
/>

// Mux automatically:
// - Detects user's bandwidth
// - Serves optimal quality
// - Switches mid-stream if connection changes
// - Provides smooth buffering

4. Progress Tracking Integration

I built a custom system on top of Mux playback:

// VideoPlayer component
const VideoPlayer = ({ videoId, muxPlaybackId, initialPosition }) => {
  const videoRef = useRef()
  const [currentTime, setCurrentTime] = useState(initialPosition)

  // Track time updates
  const handleTimeUpdate = () => {
    setCurrentTime(videoRef.current.currentTime)
  }

  // Auto-save every 15 seconds (debounced to reduce API calls)
  useEffect(() => {
    if (!videoId || !duration) return

    const trackingTimer = setTimeout(async () => {
      await videoApi.updateProgress(videoId, currentTime, duration)
    }, 15000)

    return () => clearTimeout(trackingTimer)
  }, [currentTime])

  // Resume from where user left off
  useEffect(() => {
    if (videoRef.current && initialPosition > 0) {
      videoRef.current.currentTime = initialPosition
    }
  }, [initialPosition])

  return (
    <video
      ref={videoRef}
      src={`https://stream.mux.com/${muxPlaybackId}.m3u8`}
      onTimeUpdate={handleTimeUpdate}
      controls
    />
  )
}

This creates a YouTube-like experience where users always resume from where they left off.

5. Metadata Extraction

Mux provides metadata that AyurAI uses for the UI:

const asset = await mux.video.assets.retrieve(assetId)

// Extract key metadata
const metadata = {
  duration: asset.duration,           // ← Total video length
  width: asset.width,                 // ← Video dimensions
  height: asset.height,
  fps: asset.frame_rate,              // ← For quality indicators
  createdAt: asset.created_at,
}

// AyurAI displays duration on video cards:
// "45:30" (45 minutes, 30 seconds)

6. Playback ID Strategy

Mux assigns each video a unique playback ID, separate from the asset ID. This is powerful:

// Asset ID (unique, server-side)
muxAssetId: "abc123def456"

// Playback ID (unique, client-safe)
muxPlaybackId: "ji1XhtoywRhdk402DJ9FT3IcQ4Q01HCneqqDm2OwPBdrQ"

// Users only see playback ID in URLs:
// https://stream.mux.com/ji1XhtoywRhdk402DJ9FT3IcQ4Q01HCneqqDm2OwPBdrQ.m3u8

// This means:
// - Asset IDs never exposed to clients
// - Can revoke playback IDs without deleting video
// - Fine-grained access control possible

7. Global CDN Delivery

Mux's infrastructure ensures:

User in India
  ↓
Closest Mux edge node
  ↓
Video streams with <100ms latency
  ↓
Adaptive quality based on connection

User in USA
  ↓
Different edge node
  ↓
Same experience, optimized for region

AyurAI doesn't worry about CDN setup—Mux handles it.

8. Real Example: Video Upload Workflow

Here's the complete flow when an admin uploads a wellness video:

// Step 1: Admin clicks upload
// Frontend calls: POST /api/admin/videos/upload

// Step 2: Backend creates Mux upload session
const upload = await mux.video.uploads.create({
  new_asset_settings: {
    playback_policy: ['public'],
  },
})
// Returns upload URL

// Step 3: Admin uploads directly to Mux
// (File never touches AyurAI servers)

// Step 4: Backend polls for completion
const upload = await mux.video.uploads.retrieve(uploadId)
if (upload.status === 'ready') {
  const asset = await mux.video.assets.retrieve(upload.asset_id)

  // Step 5: Save metadata to database
  const video = await prisma.video.create({
    data: {
      title: "Ayurvedic Morning Routine",
      description: "...",
      muxAssetId: asset.id,
      muxPlaybackId: asset.playback_ids[0].id,
      thumbnailUrl: `https://image.mux.com/${asset.playback_ids[0].id}/thumbnail.jpg`,
      duration: asset.duration,
      isPublished: true,
    }
  })

  // Emit event
  await ctx.emit({
    topic: 'video.published',
    data: { videoId: video.id }
  })
}

// Step 6: Motia triggers downstream events
// - Update search index
// - Notify admin of completion
// - Generate recommended videos

Result: Netflix-quality video appears in the app within minutes of upload. Zero server infrastructure concerns.

Why This Matters

By using Mux beyond just hosting, AyurAI:

✅ Saves bandwidth - No video data on my servers
✅ Saves storage - Mux stores, I just reference
✅ Saves complexity - No encoding pipelines to manage
✅ Saves costs - Pay per video delivered, not per storage
✅ Provides reliability - Netflix-grade infrastructure
✅ Enables features - Progress tracking, adaptive streaming, global delivery
✅ Scales automatically - Handle 1 user or 1M users with same infrastructure

Midnight ZK Circuit Playground: Web-based IDE to understand Midnight Network

Ashita — Sun, 07 Sep 2025 12:22:19 +0000

This is a submission for the Midnight Network "Privacy First" Challenge - Enhance the Ecosystem prompt

📌 Summary:

An interactive playground that helps developers first test out Midnight zero-knowledge proof circuits with mock circuits that replicate real-world use cases around privacy.

🔎 Scenarios:

The Playground has 3 scenarios:

Confidential Voting - Demonstrate private voter credentials while proving eligibility.
Sealed Bid Auction - Show how bid amounts remain secret until reveal phase.
Anonymous Identity Verification - Prove age/eligibility without revealing personal data.

Each scenario comes with a step-by-step proof generation with detailed explanations.

🔑 Key Features Implementation:

1. Private Input Handling & Double-Entry Prevention -

This code implements a nullifier system - a cryptographic mechanism used to prevent duplicate actions or "double-spending" type problems in various scenarios.
Generates unique identifiers (nullifiers) that can be publicly checked to ensure someone hasn't already performed a specific action, without revealing their actual identity.

client/src/hooks/useProofGeneration.ts

// Comprehensive nullifier system preventing double submissions

const nullifierCheck = (scenario: string, inputs: Record<string, string>) => {
  switch (scenario) {
    case 'voting':
      // Prevents same voter ID from voting twice
      nullifier = `voting_${inputs.voter_id}_${inputs.private_credentials}`;
      errorMessage = 'This voter ID has already cast a vote. Double voting is not allowed.';
      break;
    case 'auction':
      // Prevents same bidder from bidding multiple times
      nullifier = `auction_${inputs.bidder_secret}_${inputs.private_bidder_identity}`;
      errorMessage = 'This bidder has already submitted a bid. Multiple bids not allowed.';
      break;
    case 'identity':
      // Prevents duplicate identity verifications
      nullifier = `identity_${inputs.private_ssn}_${inputs.birth_cert_hash}`;
      errorMessage = 'This identity has already been verified. Duplicate attempts blocked.';
      break;
  }
  return { nullifier, errorMessage };
};

2. Interactive Circuit Animation -

This is a functional React component that takes data as props and renders a visual node with connection handles.

Animation System:

- Conditionally applies animate-pulse and ring styling when data.isAnimated is true
- Creates a pulsing effect with a glowing ring around animated nodes
- Uses Tailwind CSS for smooth transitions (transition-all duration-300)

Privacy Indicators:

- Red dot badge: Small circular indicator in top-right corner with "P" label.
- Text label: Shows "Private Input" below the node content.
- Both only appear when data.isPrivate is true.
- Uses red color scheme to visually distinguish private data.

client/src/components/CircuitDesigner.tsx

// Circuit nodes with privacy indicators and animation support
const CircuitNode: React.FC<CircuitNodeProps> = ({ data }) => {
  return (
    <Card className={`circuit-node transition-all duration-300 
                     ${data.isAnimated ? 'animate-pulse ring-2 ring-primary/50' : ''}`}>
      <Handle type="target" position={Position.Left} />
      <Handle type="source" position={Position.Right} />

      {/* Private data indicator */}
      {data.isPrivate && (
        <div className="absolute -top-1 -right-1 w-3 h-3 bg-red-500 rounded-full">
          <span className="text-[8px] text-white font-bold">P</span>
        </div>
      )}

      {/* Privacy labels */}
      {data.isPrivate && (
        <div className="text-[10px] text-red-500 font-medium mt-1">Private Input</div>
      )}
    </Card>
  );
};

3. Privacy-Emphasized UI Components -

The privacy-aware input fields for cryptographic applications automatically masks private text inputs as password fields (showing dots instead of plain text), apply distinctive red styling to visually distinguish sensitive data and include explanatory text reassuring users that their private information "remains encrypted and hidden during proof generation."

client/src/components/ScenarioSidebar.tsx

// Private inputs with visual encryption

<Input
  type={input.isPrivate && input.type === 'text' ? 'password' : input.type}
  className={input.isPrivate ? 'border-red-500 bg-red-50 dark:bg-red-950/20' : ''}
  placeholder={input.isPrivate ? 'Private data - encrypted' : ''}
/>

{/* Privacy explanation for each private input */}
{input.isPrivate && (
  <div className="text-xs text-red-500 mt-1 flex items-center">
    <span className="w-2 h-2 bg-red-500 rounded-full mr-1"></span>
    This data remains encrypted and hidden during proof generation
  </div>
)}

4. Zero-Knowledge Scenarios with Real Privacy Examples -

The scenario configuration file exports an array of three privacy-preserving use cases, each containing complete UI and circuit specifications.

Each scenario includes multiple components: visual circuit representation with nodes and edges showing data flow through cryptographic operations, step-by-step proof generation process with timing and status updates, circuit code written in Midnight Compact Language demonstrating the actual cryptographic logic, and input field definitions distinguishing between public and private data fields.

The Confidential Voting scenario demonstrates anonymous voting where private voter credentials and choices are processed through hash functions and nullifier checks to prevent double-voting while maintaining ballot secrecy.

The Sealed Bid Auction scenario shows how bidders can submit private bids with commitments and range proofs to ensure minimum bid requirements without revealing actual amounts until the reveal phase.

The Anonymous Identity scenario enables age verification and registry membership checks without exposing personal details like exact age or SSN, using Merkle proofs for membership verification.

client/src/data/scenarios.ts

// Confidential Voting - Real privacy protection
{
  id: 'voting',
  name: 'Confidential Voting',
  inputs: [
    { label: 'Voter ID', key: 'voter_id', type: 'text', defaultValue: 'voter_12345' },
    { label: 'Private Credentials', key: 'private_credentials', type: 'text', 
      defaultValue: 'SSN:***-**-1234', isPrivate: true },
    { label: 'Secret Nullifier', key: 'secret_nullifier', type: 'text', 
      defaultValue: 'secret_nonce_abc123', isPrivate: true },
    { label: 'Candidate Choice', key: 'choice', type: 'select', 
      options: ['Candidate A', 'Candidate B', 'Candidate C'] }
  ],
  code: `// Midnight Compact Language
circuit ConfidentialVote {
  private input voter_id: Field;
  private input choice: Field;
  private input nullifier_secret: Field;

  public input nullifier_hash: Field;
  public output commitment: Field;

  // Privacy-preserving computations
  let vote_hash = hash(voter_id, choice);
  let nullifier = hash(voter_id, nullifier_secret);
  assert(nullifier == nullifier_hash);

  commitment = hash(vote_hash, nullifier);
}`
}

// Anonymous Identity Verification - Age proof without revealing exact age
{
  id: 'identity', 
  name: 'Anonymous Identity Verification',
  inputs: [
    { label: 'Private Age', key: 'age', type: 'number', defaultValue: '25', isPrivate: true },
    { label: 'Private SSN', key: 'private_ssn', type: 'text', 
      defaultValue: '***-**-5678', isPrivate: true },
    { label: 'Private Birth Certificate Hash', key: 'birth_cert_hash', type: 'text', 
      defaultValue: '0x8a7f...b3c2', isPrivate: true }
  ],
  code: `circuit AnonymousIdentity {
    private input age: Field;
    private input identity_hash: Field;

    // Verify age >= 18 WITHOUT revealing actual age
    assert(age >= 18);

    // Generate anonymous verification token
    anonymous_token = hash(identity_hash, age);
  }`
}

🎓 Educational Impact:

This Playground demonstrates real-world zero-knowledge applications:

Confidential Voting: Proves vote validity without revealing choice or voter identity.
Private Auctions: Enables fair bidding while keeping amounts secret.
Anonymous Identity: Verifies age/credentials without exposing personal data.
Anti-Replay Protection: Prevents double submissions across all scenarios.

Video:

GitHub Repository

https://github.com/devandop/MidnightZK-Playground

Mem0 application is on Railway

Ashita — Mon, 11 Aug 2025 12:03:10 +0000

If you're reading this article, you're probably wondering what does this even mean. I get the confusion but hopefully I'll be able to explain what my Mem0 and Railway is.

What is Mem0?

**
Before understanding about Mem0,let's understand the present scenario of AI agents. When a user sends a request to the AI agent, the agent will process the request and send a response to the user without remembering the context of the request in the next session. This can lead to frustration since you would need to generate the same request all over from the previous day. What if there was a better way to deal with this?

Enter Mem0: An intelligent layer that sits along your LLM, it not only keeps track of all your past interactions but also stores long term knowledge making your agents more adaptive. With a persistent memory retention,Mem0 cuts the cost of sending repeated requests to LLM.

When RAG doesn't understand what the user had asked previously, Mem0 does the job of providing continuity to your agent by shaping it's memory. Mem0 is not a wrapper but a memory engine that is capable of deciding what to remember by filtering out irrelevant information.

Mimicking the way how humans store information, Mem0 supports different types of memory- from remembering previous conversations to building knowledge as time progresses.Mem0 is built to handle multimodal support with an upgraded feature of providing insights across sessions as a Graph Memory.

Mem0 allows you to do the following memory operations-

Add Memory
Retrieve Memory
Update Memory
Delete Memory

With Add memory, you can store user interactions that can be retrieved for later use. The add operation acts as an entry point for long-term memory knowledge. When a user sends a message, the input is sent to the LLM that extracts facts or decisions and Mem0 API then compares the new information with existing memory to detect for duplication and stores result in a vector database.

The add() operation is used in scenarios when a user has introduced a new decision/preference or when a feedback is suggested.

The Retrieve Memory in search() operation retrieves relevant memory and supports operations such as semantic similarity search and metadata filtering with logic to name a few.

Updating an exisiting memory such as updating facts is done with the update() operation.Mem0 lets you update a single specific memory or lets you batch updates of up to a thousand memories at once.

When a memory becomes irrelevant or needs to be removed for privacy, just like update() Mem0 gives you the option of deleting a specific memory or delete multiple memory IDs as a batch using delete() operation.

Deploying Mem0 Next.js Chatbot on Railway.com

Mem0 has a ready to use Next.js Companion application that let's you understand how Mem0 API can be used to create an application that better understands user context. You can add more features to improve contextual retention or integrate third-party services to extend its functionality.

Why Railway.com?

Given the ease with which Railway handles everything for you with minimal configuration, deploying Mem0 Next.js application on the platform was such a cakewalk.
All you have to do is Connect your GitHub repository,add the API keys of Mem0 and OpenAI to Railway's Variable Setting,generate a Railway domain for your application under Public Networking with a port that makes your chatbot public on the internet and watch as Railway does all the magic for you. Railway uses Nixpacks to build and deploy your code even without a Dockerfile.