DEV Community: sumeet saraf

AMTP: HTTP for the Agentic Web — A New Markdown-First Protocol for AI Agents

sumeet saraf — Tue, 26 May 2026 19:06:53 +0000

The web was built for humans. But AI agents are struggling with it.

Traditional approaches — DOM parsing, headless browsers, or forcing LLMs to read raw HTML — are brittle, expensive, and token-heavy.

Today, I'm open-sourcing AMTP (Agent Markdown Transfer Protocol) — a new protocol designed as HTTP for the Agentic Web.

The Problem

AI agents today face several major challenges when interacting with websites:

Extremely high token usage when processing full HTML pages
Brittle scraping that breaks with any UI change
No native action support — agents must simulate clicks and forms
Poor session handling for authenticated actions
Lack of real-time updates

We need a better way.

Introducing AMTP

AMTP allows websites to serve clean, semantic Markdown optimized for Large Language Models and autonomous agents, alongside their normal HTML and JSON responses.

It uses content negotiation (Accept: text/amtp) so one backend can serve all three consumers: browsers, APIs, and agents.

Key Features

~90% fewer tokens compared to HTML
Native actions, forms, and navigation (hypermedia style)
Built-in session & authentication bridging (works with your existing Passport, JWT, etc.)
Streaming support for real-time updates
Security-first design with scopes and validation
Easy integration via Express/Fastify middleware

How It Works

Here's a quick example using the AMTP middleware:

import { amtp } from '@amtp/protocol';
import express from 'express';

const app = express();

app.use(amtp({
  // Define what agents can see and do
  routes: {
    '/dashboard': {
      title: "User Dashboard",
      content: "Welcome back, {{user.name}}",
      actions: [
        {
          name: "view_orders",
          label: "View My Orders",
          href: "/orders",
          method: "GET"
        }
      ]
    }
  }
}));

From the agent side, the response is clean Markdown with embedded action metadata — perfect for LLMs to understand and act upon.

Real-World Use Cases

Agent-native SaaS platforms (Let users say “cancel my subscription” to their AI assistant)
E-commerce agents that can reliably browse and purchase
Personal automation agents that work with your existing logged-in sessions
Multi-agent workflows across different websites
Efficient crawling and indexing

Comparison

Feature	Raw HTML	JSON API	AMTP
Token Efficiency	Poor	Good	Excellent
Action Support	None	Manual	Native
Session/Auth Bridging	Hard	Medium	Built-in
LLM Readability	Poor	Medium	Excellent
Streaming	Difficult	Possible	Native

Getting Started

npm install @amtp/protocol

Visit the repository for:

Full protocol specification
Grammar and examples
Client SDK
Reference implementations

GitHub: https://github.com/sumeetingenuity/amtp

The Vision

AMTP is an early but functional step toward a truly agent-ready web — where any website can become natively compatible with AI agents without sacrificing control or security.

I’d love your feedback, contributions, and real-world use cases.

What’s the biggest pain point you face when building agents that interact with websites?

"Building a Lightweight Blockchain in Go from Scratch"

sumeet saraf — Fri, 09 May 2025 16:52:19 +0000

Hey Gophers and blockchain enthusiasts! 👋

I recently built Lite-Blockchain, a minimal yet functional blockchain implementation in Go. The goal was to demystify how blockchains work under the hood while leveraging Go’s simplicity and concurrency features. Let me walk you through what I learned!

Why Build a Blockchain in Go?
Go’s native support for concurrency (goroutines, channels) and efficient performance makes it a great fit for distributed systems like blockchains. Plus, its simplicity helps keep the codebase clean and educational.

Key Features
Proof-of-Work (PoW) Consensus: A Simple mining mechanism to secure the chain.

Transaction System: Create and validate transactions.

Pure Go: No external dependencies—just the standard library.

Lightweight: Perfect for learning.

Code Snippets
Here’s a peek at how blocks are structured:

type Block struct {  
    Timestamp    int64  
    Transactions []*Transaction  
    PrevHash     []byte  
    Hash         []byte  
    Nonce        int  
}

And how transactions are added:

func (bc *Blockchain) AddTransaction(sender, recipient string, amount int) {  
    tx := NewTransaction(sender, recipient, amount)  
    bc.PendingTransactions = append(bc.PendingTransactions, tx)  
}

Why Go for Blockchain?
Concurrency: Goroutines make parallel mining or network synchronization easier to model.

Performance: Faster than interpreted languages like Python.

Simplicity: Explicit error handling and no inheritance headaches.

Try It Out!
Clone the repo:

bash
git clone https://github.com/sumeetingenuity/Lite-Blockchain.git

Run the example:

bash
go run main.go

Contribute or Learn
This project is open-source and meant to be a learning resource! Feel free to:
⭐ Star the repo if you find it useful.
🐞 Open issues for bugs or feature requests.
🔧 Submit PRs for improvements (e.g., adding a P2P network layer).

Check out the GitHub repo to dive deeper!

I'm looking for some feedback on my project

sumeet saraf — Wed, 07 May 2025 17:43:45 +0000

I'm new to programming and not sure if I'm heading in the right direction. I'd really appreciate any feedback or constructive criticism on my project. Thanks in advance for your help!

https://github.com/sumeetingenuity/Lite-Blockchain.git