DEV Community: tutorial

How to Choose the Right AI Tutor for Exam Preparation

Rahul Jaiswal — Wed, 22 Apr 2026 06:47:01 +0000

How to Choose the Right AI Tutor for Your Exam Preparation

With dozens of AI tutor apps available in India, choosing the right one matters. Here is what to look for.

5 Things That Matter in an AI Tutor

1. Camera-Based Input

If you study from physical textbooks (most Indian students do), your AI tutor must support camera input. EaseLearn AI reads handwritten and printed questions. ChatGPT requires typing everything.

2. Indian Curriculum Awareness

A good AI tutor knows the difference between CBSE Class 12 Physics and JEE Advanced Physics. Generic AI tools give generic answers. EaseLearn adapts to your specific board and exam.

3. Step-by-Step Solutions

Not just answers — you need the working. The math solver should show every step with reasoning. This is how you learn the method, not just copy the result.

4. Visual Learning

For topics like organic chemistry or electromagnetic induction, text is not enough. Immersive Classroom generates live slides with diagrams — patent-pending technology.

5. Affordable Pricing

An AI tutor should cost less than a single tuition session. EaseLearn AI pricing: free tier available, Premium Rs 199/month.

The Best AI Tutor for Indian Students

EaseLearn AI checks all 5 boxes. 100,000+ students. Featured in ANI News and Tribune India.

Try free

EaseLearn AI — Free AI tutor. Doubt solver . Math solver . Immersive Classroom

SEO vs GEO: Which One Actually Grows Your Traffic?

yashu — Wed, 22 Apr 2026 06:15:46 +0000

In today’s fast-changing digital world, businesses are always looking for better ways to grow online. One of the biggest debates right now is SEO vs GEO. While both strategies aim to increase visibility and traffic, they work in very different ways. Understanding the difference can help you choose the right approach for your goals.
What is SEO?
Search Engine Optimization (SEO) is the process of improving your website so it ranks higher on search engines like Google. It focuses on keywords, backlinks, content quality, and technical performance. When people search for something, SEO helps your website appear in the results.
SEO has been around for years, and it still plays a major role in driving organic traffic. Businesses use SEO to create blog posts, optimize pages, and target search queries that users type every day.
What is GEO?
Generative Engine Optimization (GEO) is a newer concept. It focuses on optimizing content for AI-powered tools and search experiences. Instead of just ranking on search engines, GEO helps your content appear in AI overviews, chat-based results, and voice assistants.
With the rise of AI, users are no longer just clicking links—they are getting direct answers. This is where GEO becomes important. It helps improve AI brand visibility by making sure your content is recognized and used by AI systems.
SEO vs GEO: Key Differences
When comparing SEO vs GEO, the biggest difference lies in how users find information. SEO targets traditional search results, while GEO focuses on AI-generated answers.
SEO relies heavily on keywords and backlinks. GEO, on the other hand, prioritizes context, authority, and structured information. For example, if your content clearly answers a question, it has a better chance of being featured in AI overviews.
Another difference is user behavior. In SEO, users click on links. In GEO, users may get answers directly without visiting your site. This means your content needs to be clear, trustworthy, and well-structured.
Which One Drives More Traffic?
The answer isn’t simple. In the debate of SEO vs GEO, both strategies are important.
SEO still brings consistent traffic, especially for blogs and websites targeting search queries. It is reliable and measurable. However, GEO is growing fast as more users rely on AI tools for quick answers.
If your goal is long-term growth, combining both strategies is the best approach. SEO helps you rank, while GEO improves your chances of appearing in AI overviews and boosting AI brand visibility.
How to Use SEO and GEO Together
To win the SEO vs GEO game, you need a balanced strategy:
Use clear and simple language in your content
Answer questions directly to improve chances of appearing in AI overviews
Optimize keywords naturally (like “SEO vs GEO”)
Build authority with high-quality, helpful content
Structure your content with headings and short paragraphs
By doing this, you can benefit from both traditional search traffic and AI-driven visibility.
Final Thoughts
The future of digital marketing is not about choosing between SEO vs GEO. It’s about using both together. SEO gives you a strong foundation, while GEO prepares you for the growing world of AI search.

Serverless vs Containers: The Decision Framework That Saves CTOs From $10K/Month Mistakes

Yash Pritwani — Wed, 22 Apr 2026 06:00:54 +0000

Originally published on TechSaaS Cloud

Serverless vs Containers: The Decision Framework That Saves CTOs From $10K/Month Mistakes

The serverless vs containers debate isn't a technology debate. It's a math debate disguised as a technology debate. And most teams pick the wrong answer because they're arguing about architecture when they should be running a spreadsheet.

We've migrated workloads in both directions — Lambda to containers when costs spiraled, and containers to Lambda when teams were over-provisioning. The pattern is always the same: teams pick based on hype, then discover the economics don't work for their specific workload. By then they've spent six months building on the wrong foundation.

Here's the decision framework we use for every client engagement. It's not opinionated — it's mathematical.

The Break-Even Point Nobody Talks About

Lambda's pricing model is beautiful for low-traffic applications. You pay per invocation, per millisecond of compute time. When your app is idle, you pay zero. That's genuinely revolutionary.

But the pricing model has a dirty secret: it doesn't scale linearly. It scales worse than linearly. As your traffic grows, Lambda becomes progressively more expensive relative to containers because:

You pay per-request overhead. Every invocation has a base cost regardless of duration.
Cold starts add latency AND cost. Provisioned concurrency (the fix for cold starts) costs money whether invocations happen or not — eliminating the "pay only for what you use" advantage.
No resource sharing. Each function invocation gets its own compute allocation. Containers share resources across requests, amortizing the overhead.

The break-even point for most workloads: approximately 30 million invocations per month at 200ms average duration. Below that, Lambda is cheaper. Above that, containers are cheaper — and the gap widens with every million additional invocations.

Real Numbers From Client Migrations

Client A: Webhook Processor (Lambda Wins)

Workload: Process incoming webhooks from 200+ integrations
Traffic pattern: Extremely bursty. 90% idle time. Peaks of 500 RPS during batch sends.
Lambda cost: $180/month
Equivalent container cost: ~$400/month (need enough instances to handle peaks, paying for idle time)
Decision: Stay on Lambda. The bursty traffic pattern is exactly what serverless is designed for.

Client B: REST API (Containers Win by 6x)

Workload: Customer-facing REST API, steady traffic
Traffic pattern: 2.3 million requests per day, consistent throughout business hours
Lambda cost: $8,200/month (with provisioned concurrency for acceptable latency)
Fargate cost: $1,400/month (2 services, auto-scaling 2-8 tasks)
Decision: Migrated to Fargate. Steady traffic means Lambda's per-request pricing works against you. The provisioned concurrency bill alone was $4,000.

Client C: ML Inference (Containers Win by 7x)

Workload: Document classification pipeline, medium-sized models
Traffic pattern: 50K requests/day, models need warm loading
Lambda cost: $14,000/month (hitting timeout limits, cold starts loading models)
Self-hosted GPU containers: $2,100/month (leased A10, models stay warm)
Decision: Migrated to self-hosted containers. Lambda's 15-minute timeout and cold start penalty for large memory functions made it technically wrong AND economically wrong.

The Decision Matrix

Use this framework for any new workload:

Choose Serverless When:

Traffic is unpredictable or bursty. If your service goes from 0 to 10,000 RPS and back to 0 within minutes, serverless handles this automatically. Containers require over-provisioning for peaks, wasting money during valleys.

Functions are short-lived. Under 30 seconds execution time. Ideally under 5 seconds. If your workload consistently runs longer, you're fighting Lambda's pricing model.

The team is small and ops-averse. No patching, no scaling decisions, no capacity planning. For a team of 3 engineers shipping an MVP, the ops overhead of containers isn't worth it.

Workloads are event-driven. S3 triggers, SQS processing, cron jobs that run once per hour, webhook handlers. These are Lambda's sweet spot — truly pay-per-use.

You're prototyping. Need to validate an idea in a week? Lambda gets you from code to production with zero infrastructure decisions.

Choose Containers When:

Traffic is sustained and predictable. More than 1 million requests per day with a consistent pattern. The per-request overhead of Lambda adds up fast.

You need persistent connections. WebSockets, gRPC streams, long-polling, SSE. Lambda's request-response model doesn't support these patterns.

Cold start latency is unacceptable. Even with provisioned concurrency, Lambda cold starts add 100-500ms for basic functions and 1-5 seconds for functions with large dependencies. Containers start once and serve thousands of requests.

You need local state or caching. In-memory caches, connection pools, loaded ML models. Lambda functions are stateless by design — every optimization that relies on state breaks the model.

Your monthly serverless bill exceeds $3,000. This is the inflection point where the math almost always favors containers. Run the actual comparison.

The Hybrid Approach (What We Recommend)

Most production systems shouldn't be 100% either. The winning pattern:

Containers for your core services: APIs, web servers, databases, queues, anything with sustained traffic
Serverless for glue code: event processing, file transformations, scheduled jobs, webhooks, async background tasks

This hybrid approach typically costs 60-70% less than going all-in on either strategy.

The Migration Playbook

If you've determined you're on the wrong architecture, here's the migration path:

Lambda → Containers:

Identify the expensive functions. Sort by monthly cost. Usually 3-5 functions account for 80% of your Lambda bill.
Group by latency requirement. Functions that need sub-100ms response go into your primary service. Batch functions can be background workers.
Containerize incrementally. Move one function at a time. Keep Lambda as a fallback for 2 weeks after each migration.
Right-size from day one. Use actual traffic data to size your containers. Don't guess — check CloudWatch metrics for peak and average utilization.

Containers → Lambda:

Identify low-utilization services. If a container averages under 10% CPU, it's a candidate for serverless.
Check for state dependencies. Any in-memory cache, connection pool, or loaded model means the function needs provisioned concurrency — factor that cost in.
Extract event-driven logic. Cron jobs, webhook handlers, and async processors are the lowest-risk migrations.

Common Mistakes

"Serverless is always cheaper." It's cheaper at low scale. It's expensive at high scale. The marketing materials show the low-scale numbers.

"Containers are too complex." Fargate and Cloud Run eliminate most operational overhead. You don't need to manage EC2 instances to run containers.

"We'll optimize Lambda later." Lambda cost optimization (reducing memory, optimizing cold starts, batching) has diminishing returns. If the architecture is wrong, no optimization saves you.

"Our traffic might spike someday." Design for today's traffic with the ability to scale. Don't pay 6x more today because traffic might spike in 18 months. You can migrate later.

The One Question That Cuts Through the Debate

Ask yourself: "If my traffic doubles next month, does my bill double or stay roughly the same?"

If it doubles: you're on serverless or poorly-sized containers.
If it stays roughly the same: you're on well-sized containers.

For sustained workloads, you want the second answer. For unpredictable workloads, the first answer is actually correct — you'd rather your bill scale with actual usage than pay for unused capacity.

At TechSaaS, we help teams make this decision with real data, not gut feelings. We'll analyze your current architecture, run the cost comparison, and build the migration plan if the math says you should move. Most clients save 40-70% on their cloud bill within the first month after migration.

Self-Hosting in 2026: The Complete Infrastructure Stack (82 Containers, $0 Cloud Bill)

Yash Pritwani — Wed, 22 Apr 2026 06:00:21 +0000

Originally published on TechSaaS Cloud

Self-Hosting in 2026: The Complete Infrastructure Stack

We run 82 production containers on a single physical server. Grafana, Prometheus, Gitea, Directus CMS, n8n automation, Loki logging, PostgreSQL, Redis, FalkorDB, multiple AI models, and dozens of web applications. Our monthly cloud bill is zero dollars.

This isn't a hobby project. This is a production infrastructure serving real users, with 99.9% uptime over the last year, automated backups, monitoring that pages us before users notice issues, and CI/CD that deploys on every push.

The 2026 self-hosting stack is a fundamentally different proposition than it was even two years ago. The tooling has matured. Docker Compose handles orchestration that once required Kubernetes. Cloudflare Tunnels provide zero-trust access without opening any ports. Reverse proxies auto-provision SSL certificates. And the economics have shifted — cloud costs have risen 15-20% while hardware costs have dropped.

Here's the exact stack, why we chose each component, and the real numbers.

The Hardware Layer

Proxmox VE as the hypervisor. Running LXC containers for lightweight isolation between tenants. The host server has 13GB RAM, NVMe storage across multiple logical volumes, and an NVIDIA GTX 1650 for AI inference workloads.

Why Proxmox over bare Linux? Live migration, snapshot-based backups, web UI for emergency management, and proper resource isolation between workloads. It's the enterprise hypervisor that's actually free.

Storage layout:

/mnt/containers (148GB): Docker data root — all container images and volumes
/mnt/projects (84GB): Git repositories, CI/CD artifacts, application code
/mnt/databases (15GB): PostgreSQL, Redis, FalkorDB, SQLite databases
Root (69GB): OS, configs, logs

The Networking Layer

Traefik as the reverse proxy. Auto-discovers Docker containers via labels, provisions Let's Encrypt SSL, handles routing, load balancing, and rate limiting. Configuration is entirely label-based — no nginx configs to maintain.

Cloudflare Tunnels for zero-trust access. No ports open on the firewall. Not 80, not 443, not SSH. Everything routes through Cloudflare's network, which handles DDoS protection, CDN caching, and access control. This is genuinely more secure than most cloud deployments.

Authelia for single sign-on. One login across all 82 services. TOTP two-factor authentication. Session management. Access policies per-service. No paying $15/user/month for Auth0 or Okta.

The networking stack gives us: automatic SSL, zero-trust access, SSO, DDoS protection, and CDN caching. Total cost: $0 (Cloudflare free tier + open-source tools).

The Monitoring Stack

Prometheus scrapes metrics from every container every 15 seconds. Recording rules pre-compute expensive queries. 90-day retention.

Grafana visualizes everything. Three-tier dashboard hierarchy: overview, service detail, and debug dashboards. Burn-rate alerts instead of static thresholds to minimize false alarms.

Loki + Promtail for centralized logging. Every container's stdout goes to Loki, queryable via the same Grafana interface. LogQL queries correlate logs with metrics during incidents.

Uptime Kuma for external monitoring. 28 monitors checking every service from outside the network. If our server is unreachable, we know within 60 seconds.

Alert routing: Prometheus → Grafana → ntfy push notifications → phone. Average alert-to-acknowledgment time: 3 minutes.

The CI/CD Layer

Gitea as the Git host. Self-hosted GitHub alternative with Actions support. All repositories push-mirror to GitHub for redundancy, but Gitea is the primary for development.

Gitea Actions for CI/CD. Docker-based runners execute on the same host. Build, test, security scan, deploy — all triggered on push. Average pipeline: 90 seconds from push to production.

Docker Registry (self-hosted). Built images stay local. No pulling from Docker Hub on every deploy. Faster, more reliable, no rate limits.

The Data Layer

PostgreSQL for relational data. Shared across services with schema-level isolation. Daily automated backups with point-in-time recovery.

Redis for caching and session storage. Sub-millisecond reads. Pub/sub for real-time features.

FalkorDB for graph data. Knowledge graphs, relationship mapping, semantic search. Runs on the Redis wire protocol.

SQLite for lightweight applications that don't need a full PostgreSQL database. Sometimes the right answer is the simplest one.

All databases back up nightly to an off-site location. Retention: 30 days of daily snapshots.

The AI/ML Layer

Ollama running Gemma and other open-source models. Local inference on the GTX 1650 — 4GB VRAM is enough for 7B models quantized to 4-bit.

vLLM for production inference endpoints. OpenAI-compatible API. Model swapping without downtime.

This is why the GTX 1650 is in the server. For $200 in hardware, we have unlimited local AI inference with no per-token API costs. Classification, summarization, embedding generation — all free after the hardware purchase.

The Automation Layer

n8n for workflow automation. 14 active workflows handling: content scheduling, email processing, social media posting, webhook routing, and monitoring integrations.

Cron + systemd for lightweight scheduling. Anything that doesn't need n8n's visual builder runs as a systemd timer.

Custom scripts for domain-specific automation. LinkedIn growth engine, content pipeline dispatcher, analytics collection — all containerized, all monitored.

The Real Cost Comparison

Here's what the equivalent infrastructure would cost on AWS:

Component	Self-Hosted	AWS Equivalent	Monthly AWS Cost
Compute (82 containers)	Included	ECS/Fargate	$1,200
PostgreSQL	Included	RDS	$180
Redis	Included	ElastiCache	$120
Monitoring (Prometheus+Grafana)	Included	CloudWatch + Managed Grafana	$350
CI/CD	Included	CodePipeline + ECR	$80
Git hosting	Included	CodeCommit or GitHub Teams	$50
Reverse proxy + SSL	Included	ALB + ACM	$100
AI inference	Included	SageMaker	$300
Logging	Included	CloudWatch Logs	$150
Total	~$30 electricity	—	$2,530/month

That's $30,360 per year in cloud costs eliminated. The server hardware (roughly $2,000) paid for itself in the first month.

When Self-Hosting Is Wrong

Self-hosting isn't for everyone. Don't do this if:

You don't have someone who understands Linux. When things break at 3am, you need someone who can SSH in and debug.
You need five-nines uptime. Single-server self-hosting gives you three nines to four nines. For five nines, you need geographic redundancy that cloud provides naturally.
Your team is tiny and shipping is the priority. If you're a team of 3 racing to product-market fit, managed services save engineering time that's better spent on product.
Compliance requires specific certifications. SOC2, HIPAA, PCI compliance is dramatically easier with certified cloud infrastructure than self-hosted.

Self-hosting makes sense when you have sustained workloads, predictable traffic, a team that can maintain infrastructure, and a desire for full control and zero vendor lock-in.

Getting Started

The 2026 self-hosting starter path:

Start small. One used mini-PC ($200-400), Proxmox, Docker Compose with Traefik + monitoring.
Add services incrementally. Move one cloud service at a time. Start with the expensive ones.
Cloudflare Tunnel from day one. Zero-trust access without port forwarding. Secure by default.
Monitor everything. Prometheus + Grafana + alerting before you add any production workloads.
Backup to external storage. Never have all your eggs in one physical location.

The complete Docker Compose file for our 82-service stack is available in the guide linked below. It's opinionated, tested in production for over a year, and ready to deploy.

At TechSaaS, we help teams design and implement self-hosted infrastructure that matches or exceeds cloud reliability. Whether you're repatriating from cloud or building from scratch, we bring the architecture expertise so your team doesn't have to learn through expensive mistakes.

SaaS Metrics That Matter: The 5 Numbers Your Board Should Actually Care About

Yash Pritwani — Wed, 22 Apr 2026 06:00:18 +0000

Originally published on TechSaaS Cloud

SaaS Metrics That Matter: The 5 Numbers Your Board Should Actually Care About

Every SaaS board meeting starts the same way. MRR is up. Churn is down. Everyone nods. The meeting ends.

Six months later the company is running out of runway and nobody can explain why the numbers looked good but the business isn't working.

MRR and churn are lagging indicators. They tell you what already happened. They're the rearview mirror of your business. By the time churn spikes, the customers have already been unhappy for months. By the time MRR stalls, the pipeline has been dry for a quarter.

After building analytics infrastructure for 12 SaaS companies — from seed-stage to Series C — these are the five metrics that actually predict whether your business will be alive in 18 months. They're leading indicators. They tell you what's about to happen, not what already did.

1. Net Revenue Retention (NRR)

What it is: The percentage of revenue you retain from existing customers after accounting for upgrades, downgrades, and churn. It's your expansion revenue minus your contraction and churn.

Formula: (Starting MRR + Expansion - Contraction - Churned MRR) / Starting MRR × 100

Why it matters more than gross churn: A 5% monthly churn rate sounds bad. But if your remaining customers are expanding by 8%, your NRR is 103% — meaning you grow even without new customers. Gross churn hides this crucial nuance.

Benchmarks:

Below 90%: You're dying. Existing customers are shrinking faster than you can replace them.
90-100%: Treading water. Growth depends entirely on new customer acquisition.
100-110%: Healthy. Some organic growth from existing base.
110-120%: Strong. Expansion is a meaningful growth engine.
120%+: Elite. You could stop selling to new customers and still grow. Snowflake (130%), Datadog (125%), Twilio (127%).

The insight: If your NRR is below 100%, your sales team is filling a leaky bucket. Every new customer you close is partially offset by revenue you're losing from existing customers. Fix retention before you scale acquisition.

2. Revenue Per Employee (RPE)

What it is: Total ARR divided by total headcount. The simplest measure of organizational efficiency.

Why your board should watch this: It's the earliest warning sign of an unsustainable business. You can grow MRR by hiring more salespeople, but if revenue per employee is declining, you're buying growth by spending future runway.

Benchmarks:

Below $100K RPE: Dangerously inefficient. Common in early-stage with heavy R&D investment.
$100K-$200K RPE: Acceptable for growth-stage companies still building the product.
$200K-$300K RPE: Healthy. The team is productive and the product sells efficiently.
$300K+ RPE: Highly efficient. Usually means strong product-led growth or excellent sales efficiency.

The insight: When RPE drops two quarters in a row, you're hiring faster than you're growing. Either your new hires aren't productive yet (3-6 month ramp), or you're over-hiring for the growth rate. Either way, the board should be asking why before the next round of fundraising.

3. Time to Value (TTV)

What it is: The number of days between a customer signing up and reaching their first meaningful outcome — the "aha moment" that makes them sticky.

Why it predicts survival: TTV directly correlates with retention. Customers who reach value in the first week retain at 2-3x the rate of customers who take a month. Every day of friction between signup and value is a day the customer might leave.

How to measure it: Define your activation event — the action that correlates most strongly with long-term retention. For Slack, it was 2,000 messages sent. For Zoom, it was the first meeting with 3+ participants. For your product, it's the specific action after which customers almost never churn.

Benchmarks:

Under 1 day: Exceptional. Usually product-led with self-serve onboarding.
1-7 days: Good. Most successful B2B SaaS hits value within a week.
7-30 days: Acceptable for complex enterprise products with implementation requirements.
30+ days: Dangerous. You're losing customers before they ever experience the product.

The insight: If TTV is growing, your product is getting more complex without getting more valuable. Simplify onboarding. Remove steps. Pre-configure everything possible. The fastest path to retention is the fastest path to value.

4. Expansion Revenue Percentage

What it is: The percentage of your new MRR that comes from existing customers upgrading, buying add-ons, or increasing usage — versus new logo acquisition.

Formula: Expansion MRR / Total New MRR × 100

Why it's more important than new customer count: Expansion revenue costs 5-7x less to acquire than new logo revenue. Your CAC for existing customers is nearly zero — they already trust you, already have the product integrated, already know the value. Every dollar of expansion revenue has dramatically better unit economics.

Benchmarks:

Below 20%: Over-dependent on new sales. Your existing customers aren't finding enough value to pay more.
20-30%: Healthy mix. Most growth is net-new but expansion contributes meaningfully.
30-40%: Strong. Your product grows with customers. Pricing captures increasing value.
40%+: Exceptional. Your product is truly embedded in customer workflows and grows as they grow.

The insight: If expansion revenue is below 20%, ask yourself: do customers have a natural path to pay you more? Is there usage-based pricing? Are there meaningful add-ons? If the only way to grow revenue is acquiring new logos, you're building a linear business in a world that rewards compounding ones.

5. CAC Payback Period

What it is: The number of months it takes to recoup the cost of acquiring a customer through their recurring revenue. It tells you how long your money is "underwater" before a customer becomes profitable.

Formula: CAC / (MRR × Gross Margin %)

Why it's better than CAC alone: A $50K CAC is fine if the customer pays $10K/month. A $5K CAC is terrible if the customer pays $100/month and churns at month 6. Payback period contextualizes acquisition cost against the actual revenue pattern.

Benchmarks:

Under 6 months: Excellent. Money comes back fast. You can reinvest aggressively.
6-12 months: Good. Standard for healthy B2B SaaS. Most VCs expect this.
12-18 months: Concerning. Cash is tied up too long. Growth requires heavy funding.
18+ months: Unsustainable without deep pockets. You're essentially lending money to customers for over a year before seeing returns.

The insight: If your payback period is growing while your sales velocity stays the same, you're spending more to acquire lower-value customers. Either your ICP has shifted, your pricing is wrong, or your sales team is going downmarket to hit targets.

Putting It Together: The Dashboard That Matters

Stop showing your board a wall of 20 metrics. Show them these five in a single-page dashboard with trend lines:

Metric	Current	Trend	Target
NRR	108%	↑	>115%
RPE	$185K	→	>$200K
TTV	4.2 days	↓	<3 days
Expansion Revenue	24%	↑	>30%
CAC Payback	9.8 mo	→	<8 months

If all five trend in the right direction, your business is compounding. If two or more are trending wrong, you have a structural problem that MRR growth is masking. The board should be asking about root causes, not celebrating topline numbers.

The One Metric to Rule Them All

If you can only track one beyond MRR, make it NRR. It's the single strongest predictor of SaaS outcomes. Companies with NRR above 120% have a 95% probability of reaching $100M ARR if they maintain it for 3+ years. Companies below 90% NRR almost never recover without a fundamental product change.

NRR is the metric that tells you whether your product is genuinely solving a growing problem for your customers, or whether you're churning through them faster than you can find new ones.

At TechSaaS, we build custom analytics dashboards that make these metrics visible, actionable, and automated. If your board is still squinting at spreadsheets instead of real-time dashboards, we should talk.

Togel singapore

staffhose — Wed, 22 Apr 2026 05:34:18 +0000

Togel Singapore dimulai pada 1968 untuk mendanai pembangunan negara. Seiring waktu, menjadi salah satu permainan judi paling populer di Asia
Wajib coba : http://info.ketuaprediksi.com/

How to Build an AI Chatbot for Your Business (Step-by-Step Guide for 2026)

Ash Bagda — Wed, 22 Apr 2026 05:32:25 +0000

The short answer: Building an AI chatbot in 2026 is a 6-phase process: define scope, choose the right platform, connect your data, train on real conversations, test failure modes, then launch with a human fallback. Most projects fail in phases 3 and 4, not phase 1.

Most guides on this topic start with "choose a platform" and end with "you're live." That's the optimistic version. The reality has more steps in the middle that nobody warns you about, specifically around data preparation and what happens when the bot doesn't know something.

This guide covers the full process, including the parts that slow projects down.

Why most chatbot builds fail before they start

The standard advice is: pick a chatbot tool, connect it to your website, write some FAQs, go live. That works for simple use cases. For anything involving real customer data, CRM integration, or meaningful deflection rates, it breaks quickly.

Most teams start by evaluating vendors. That's backwards. Until you know what data the bot needs to access, what conversations it needs to handle, and what your fallback process looks like, you can't evaluate platforms meaningfully. You end up choosing based on the demo rather than your actual requirements.

The other failure point is training data. AI chatbots learn from examples. If you train on your FAQ page, you get a bot that answers FAQ-page questions. Real customer queries are messier, more varied, and often completely different from what your marketing team wrote in the help docs. Teams that skip this discovery step launch bots with 20–30% coverage rates, which frustrates users and delivers no ROI.

Phase 1: Define scope before touching any tool

Before any vendor is involved, decide what the bot will and won't handle. This is the decision most teams skip, and it's why most bots launch underperforming.

Pull your last 3 months of support tickets, chat logs, or email inquiries. Categorise them. You're looking for clusters: groups of similar questions that appear repeatedly. Anything that clusters at 5% or more of total volume is a candidate for automation.

Then apply a simple filter to each cluster:

Does answering this require data from a system (CRM, inventory, orders)? If yes, mark it as "integrated" (harder to build, but higher ROI).
Does answering this require human judgement every time? If yes, exclude it from scope.
Is the answer relatively stable, or does it change frequently? Frequently changing answers need a content management process behind them.

By the end of this phase you should have a list of in-scope topics, an estimate of what percentage of total volume they represent, and a list of systems the bot will need to connect to.

The most common mistake is including everything. A bot scoped to handle 80% of queries in v1 will take 3x longer to build and launch with lower quality than one that handles 30% well.

Phase 2: Choose your platform based on requirements, not demos

Vendor selection should happen after scope definition, not before. Use the integration list from phase 1 as your filter.

Take your list of required system integrations and ask every vendor the same question: "Can you connect to X natively, or does this require custom development?" The answer tells you more than any feature comparison.

The other question that matters: "How do we update content after launch?" If the answer involves a developer every time, plan for slow iteration.

For most business deployments in 2026, the decision comes down to three options. Low-code platforms (Voiceflow, Botpress, similar) build faster with less flexibility on integrations — good for contained use cases. LLM-native builds (custom GPT wrappers, Claude API, similar) are more flexible but require more technical ownership, better for complex or frequently changing use cases. All-in-one CX platforms (Intercom, Zendesk AI, similar) are easiest if you're already on their helpdesk, but limited when you need custom logic.

There's no universally correct answer. The right choice depends on your technical capacity and what systems you need to integrate.

Phase 3: Connect your data (this is where most projects stall)

This phase has two components that teams frequently confuse, and mixing them up is what causes timelines to slip.

The first is knowledge base content: documents, FAQs, product information, policies. This is the easier part. Most platforms have document ingestion built in.

The second is live system integrations, connecting to your CRM, order management system, inventory database, or booking system so the bot can look up real-time data about a specific customer or product. This is where projects slow down.

For each integration you need an API endpoint that returns the data, authentication that works in the chatbot environment, and error handling for when the system returns nothing or returns an error.

Don't underestimate the error handling. A bot that crashes when the CRM returns an empty result is worse than a bot with no integration at all. An e-commerce company connecting order tracking needs to handle at least five states: order found and shipped, order found and processing, order not found, order status unknown, and system unavailable. Each needs a different response.

Phase 4: Train on real conversations, not ideal ones

Pull 200–300 real customer messages from your support history for each in-scope topic. Look at the full range, not just the clean well-worded questions but the short ones, the misspelled ones, the ones that combine two topics in one message.

For LLM-based bots, this training takes the form of examples and instructions in the system prompt rather than traditional ML training. You're teaching the model what this question looks like in practice, what a good answer contains, and what to do when the query is ambiguous.

For rule-based or intent-based platforms, this means building out alternative phrasings for each intent. Most teams build 3–5 examples per intent. The bots that work well have 15–20.

I've found that the questions that break bots most often are the two-part ones: "How do I return this and will I get a full refund?" Those require the bot to recognise multiple intents in one message and respond to both. Worth testing these specifically before launch.

Phase 5: Test failure modes, not just happy paths

Most QA processes test the questions the bot is supposed to answer. That's necessary but not enough. You also need to test:

Questions just outside scope (what does the bot do when it doesn't know?)
Ambiguous questions with multiple valid interpretations
Hostile or frustrated inputs ("this is useless, I want a human")
Questions in different languages if multilingual support is claimed
Edge cases in integrations (expired sessions, malformed data, empty results)

The bot's behaviour when it fails matters as much as when it succeeds. A bot that says "I'm not sure, let me connect you with someone who can help" and hands off cleanly is far better than one that gives a wrong answer confidently.

Define your fallback logic before launch. What triggers a handoff, what information gets passed to the human agent, and how the handoff appears to the customer.

Phase 6: Launch with a human fallback, then expand scope

Resist the pressure to launch with everything. Launch with your highest-volume, lowest-complexity cluster first. Get real usage data. See what questions come in that you didn't anticipate. Use that to improve coverage before adding the next cluster.

Monitor these metrics weekly in the first month:

Containment rate: percentage of conversations handled without escalation
Escalation reason: why did the bot hand off?
User satisfaction on bot-handled conversations (simple thumbs up/down is enough)
False positive rate: bot answered but gave the wrong answer

The goal in month 1 is not maximum deflection. It's understanding what the bot gets right and what it gets wrong. That understanding is what makes month 3 significantly better.

Realistic timeline to expect

A mid-complexity deployment runs 8–12 weeks from kick-off to live. Here's how that typically breaks down:

Weeks 1–2: Scope definition and ticket analysis
Weeks 3–4: Vendor selection and integration scoping
Weeks 5–7: Platform setup, knowledge base, and integrations
Weeks 8–9: Training on real conversations and QA
Week 10: Soft launch on limited traffic
Weeks 11–12: Data review and first iteration

Simple FAQ-only bots can move faster. Anything with 3+ system integrations will likely need more time in weeks 5–7.

Who this works best for

This process works well for businesses that:

Have enough conversation volume to justify the build (50+ queries per day minimum)
Have technical resource to own integrations, or a vendor who will
Are willing to dedicate 2–3 weeks to the scope and training data phases before building anything

The teams at FNA Technology work with businesses across the Gulf region on exactly this process. In most cases the scope and data phases are what determine whether a deployment succeeds, not the platform chosen.

Who this is NOT for

Being honest about the limits is more useful than pretending otherwise.

Teams that need something live in two weeks. Rushed builds produce bots with low coverage and poor failure handling — which damages trust with customers faster than having no bot at all.
Businesses where every query is unique. Chatbots return value at scale on repeatable questions. If your support is 80% bespoke, the ROI isn't there.
Companies without CRM or system data to connect to, who are hoping the bot will somehow personalise responses. Without live data access, personalisation isn't possible.

Frequently asked questions

Q: Do I need a developer to build an AI chatbot?

For FAQ-only bots using low-code platforms, no. For anything requiring CRM or system integrations, yes, either in-house or through a vendor who owns the integration work. The AI layer is increasingly no-code. The data plumbing still requires technical skill.

Q: What's a realistic budget for a business chatbot in 2026?

A basic deployment on a low-code platform runs $3,000–$8,000 in setup, plus $200–$800/month in platform fees depending on volume. A custom-built LLM bot with multiple integrations runs $15,000–$50,000 in initial build cost. Ongoing maintenance is often underbudgeted. Plan for 10–15% of build cost annually.

Q: How do I measure whether the chatbot is working?

Containment rate (conversations resolved without human handoff) is the primary metric. Secondary metrics: average handle time on escalated conversations (should drop as the bot improves pre-summarisation), and customer satisfaction scores on bot-handled conversations. Revenue impact is measurable in sales qualification use cases. Track demo conversion rate before and after.

Q: Can the same chatbot handle WhatsApp and website?

Most modern platforms support multichannel deployment from a single bot configuration. The conversation logic is the same; the channel is a delivery layer. WhatsApp has specific rules around message templates for outbound messaging that add some complexity, but for inbound query handling, the setup is largely the same. For businesses in the Gulf region where WhatsApp is the primary customer channel, the WhatsApp chatbot development service is built specifically for that context.

Q: What happens when the bot gets something wrong?

This is the question most teams don't ask until after launch. The answer should be built into your fallback logic before you go live. At minimum: the bot should detect low-confidence responses and offer to connect the user with a human rather than guessing. Logging incorrect responses for review and correction should be a weekly process in the first 90 days.

If you'd rather have an experienced team handle the build, explore real-world use cases and the full range of services here:
👉FnA Technology LLP

The Complete Guide to AI Tutors in India 2026

Rahul Jaiswal — Wed, 22 Apr 2026 05:30:17 +0000

The Complete Guide to AI Tutors in India 2026

If you are a student in India looking for an AI tutor, this guide covers everything you need to know — what AI tutors actually do, how they compare to human tutors, which ones are worth using, and how to get the most out of them.

What Is an AI Tutor?

An AI tutor is an artificial intelligence system that teaches you like a human tutor would — explaining concepts, solving your doubts, adapting to your learning pace, and testing your understanding. Unlike a chatbot that just answers questions, a good AI tutor structures lessons, checks comprehension, and adjusts its teaching approach based on how you respond.

The best AI tutor available in India right now is EaseLearn AI. It combines camera-based doubt solving, adaptive AI tutoring, math solving, and a patent-pending Immersive Classroom that generates live visual lessons in real-time.

Why Indian Students Need AI Tutors

Private tutoring in India costs Rs 2,000-10,000 per month per subject. For a family earning Rs 30,000/month, that is 25-70% of household income. 80% of Indian students cannot afford quality tutoring.

An AI tutor like EaseLearn AI costs Rs 199/month for ALL subjects — or free for basic features. It is available 24/7, adapts to your pace, and works in Hindi and English.

As covered by ANI News and Tribune India, EaseLearn AI has crossed 100,000 users with zero marketing spend — entirely through word of mouth.

Best AI Tutors for Indian Students in 2026

1. EaseLearn AI — Best Overall AI Tutor

EaseLearn AI is purpose-built for Indian students preparing for JEE, NEET, CBSE, ICSE, and state board exams.

Key features:

Camera-based doubt solver — point at any question, get step-by-step solutions in 3 seconds
AI tutor that adapts explanations to your level
Math solver for Class 6 to JEE Advanced
Immersive Classroom — AI generates live slides with diagrams while teaching (patent-pending)
PYQ solver with pattern analysis
Quiz generator with adaptive difficulty
Hindi and English support

Price: Free tier (5 doubts/day) | Premium Rs 199/month
Users: 100,000+
Backed by: AWS, Google, Anthropic, NVIDIA, MeitY

2. ChatGPT — Best for General Questions

ChatGPT is powerful but not built for Indian exam preparation. It does not know the difference between CBSE and JEE level physics. No camera input. No structured step-by-step solutions.

Price: Free / $20/month (Rs 1,700)

3. Khan Academy Khanmigo — Best International Option

Khanmigo is Khan Academy's AI tutor powered by OpenAI. Good for conceptual learning but not optimized for Indian curriculum. Not available in Hindi. Expensive at $44/month.

AI Tutor vs Human Tutor — Honest Comparison

Feature	AI Tutor (EaseLearn)	Human Tutor
Available 24/7	Yes	No (fixed hours)
Adapts to your pace	Fully adaptive	Depends on tutor
All subjects	Yes	Usually 1-2
Doubt resolution time	3 seconds	Next session
Visual lessons	Live AI-generated	Whiteboard
Cost per month	Rs 0-199	Rs 2,000-10,000/subject
Hindi support	Yes	Depends
Camera input	Yes	No

How to Use an AI Tutor Effectively

Start with diagnostic testing — Use the AI tutor's quiz generator to find your weak chapters before studying
Use camera doubt solving — When stuck on a problem, snap a photo instead of skipping it
Ask follow-up questions — If you do not understand a solution, ask "explain differently" or "why this formula?"
Practice with AI quizzes — Adaptive quizzes find gaps you did not know existed
Use Immersive Classroom for visual topics — Organic chemistry mechanisms, physics diagrams, biology processes

Frequently Asked Questions About AI Tutors

Q: Can an AI tutor really replace a human tutor?
A: For 80% of daily study needs — yes. AI handles doubt solving, concept explanation, and practice better than most tutors. Human tutors still win for motivation and complex problem-solving discussions.

Q: Is EaseLearn AI really free?
A: Yes. The free tier gives 5 doubt solutions per day. Premium is Rs 199/month for unlimited access.

Q: Which AI tutor is best for JEE preparation?
A: EaseLearn AI — it knows JEE-specific methods, has PYQ analysis, and the camera doubt solver works for handwritten HC Verma problems.

Q: Do AI tutors work in Hindi?
A: EaseLearn AI works in Hindi and English. Most other AI tutors (ChatGPT, Khanmigo) are English-first.

EaseLearn AI — India's #1 free AI tutor. Doubt solver . AI tutor . Math solver . Immersive Classroom. Featured in ANI News and Tribune India.

Getting Started with the ant CLI: Deploy Claude Agents

Avinash Sangle — Wed, 22 Apr 2026 05:25:26 +0000

This article was originally published on avinashsangle.com.

The ant CLI is Anthropic's official command-line client for the Claude API, and it's the fastest way to create, configure, and manage cloud-hosted agents without writing application code. From install to a running managed agent in under 10 minutes.

TL;DR

The ant CLI is Anthropic's official Go-based CLI for the Claude API, launched April 2026. It manages agents, environments, and sessions from your terminal.
Install on macOS with brew install anthropics/tap/ant. Linux and Go installs are also supported.
Define agents as YAML files, check them into Git, and deploy through CI - full GitOps for your agent configs.
Sessions cost $0.08/hour (billed to the millisecond) plus standard Claude token rates. Idle time is free.

What Is the ant CLI?

The ant CLI shipped alongside Claude Managed Agents on April 8, 2026, and it's built specifically for developers who want to create, configure, and run cloud-hosted agents without writing wrapper code. The GitHub repo already has over 300 stars in its first ten days.

It follows a resource-based command structure: ant [resource] <command> [flags...]. Think of it like kubectl for Claude agents. You can pipe YAML into it, extract fields with GJSON transforms, and chain commands in shell scripts. If you've worked with any modern infrastructure CLI, the patterns will feel familiar.

One thing to clarify early: the ant CLI and Claude Code solve different problems. Claude Code is your interactive coding assistant in the terminal - you talk to it, it writes code, and you pay through a subscription. The ant CLI is a programmatic API client for managing hosted agent infrastructure. You authenticate with an API key, and you're billed at standard API rates. I use both daily, and they complement each other well. Claude Code even understands how to shell out to ant natively.

How to Install the ant CLI

There are three installation paths depending on your platform. If you're on macOS, Homebrew is the fastest route.

macOS (Homebrew)

# Install from Anthropic's tap
brew install anthropics/tap/ant

# Clear the macOS quarantine flag (required)
xattr -d com.apple.quarantine "$(brew --prefix)/bin/ant"

# Verify
ant --version

That quarantine step trips people up. macOS flags unsigned binaries downloaded by Homebrew, and without clearing it you'll get a "cannot be opened because the developer cannot be verified" error. It's a one-time thing.

Linux / WSL (curl)

VERSION=1.2.1
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m | sed -e 's/x86_64/amd64/' -e 's/aarch64/arm64/')

curl -fsSL \
  "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
  | sudo tar -xz -C /usr/local/bin ant

From Source (Go 1.22+)

go install github.com/anthropics/anthropic-cli/cmd/ant@latest
export PATH="$PATH:$(go env GOPATH)/bin"

Set Your API Key

Once installed, set your Anthropic API key. The CLI reads it from the ANTHROPIC_API_KEY environment variable:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

You can generate an API key from the Anthropic Console. I keep mine in a .env file that my shell sources on startup, but any secret management approach works.

Shell Completions

The ant CLI supports completions for bash, zsh, fish, and PowerShell. For zsh (the default macOS shell):

# Generate zsh completions
ant completion zsh > ~/.zfunc/_ant

# Add to your .zshrc if not already there
echo 'fpath=(~/.zfunc $fpath)' >> ~/.zshrc
echo 'autoload -Uz compinit && compinit' >> ~/.zshrc

Tab completion saves a lot of time when working with the beta: namespaced commands, which can get long.

Core Concepts - Agents, Environments, and Sessions

Before you create anything, it helps to understand how the four core pieces fit together.

Agent - A versioned configuration defining the model, system prompt, tools, and MCP server connections. Think of it as a blueprint. Each update creates a new version, so you can roll back if needed.

Environment - A container template specifying pre-installed packages (pip, npm) and networking rules. Create it once, reference it by ID. Multiple sessions can share one environment config, but each gets its own isolated container.

Session - A running instance that pairs an agent with an environment. It has its own container, filesystem, and conversation history. Sessions are where the actual work happens.

Events - The communication protocol. You send user events (messages, interrupts, tool confirmations) and receive agent events (messages, tool calls, thinking). Everything is event-based and streamable.

The flow works like this: you create an agent (the what), create an environment (the where), start a session linking them together, and then communicate through events. Anthropic handles the container orchestration, tool execution, and conversation state. According to the official docs, sessions cost $0.08 per session-hour billed to the millisecond, and idle time doesn't count.

Creating Your First Agent with the ant CLI

Let's build a simple code review agent. I'll walk through each step so you can see exactly what the CLI does at each stage. All managed agent commands sit under the beta: prefix since the feature is still in beta.

Step 1: Create the Agent

ant beta:agents create \
  --name "Code Reviewer" \
  --model claude-sonnet-4-6 \
  --system "You are a senior code reviewer. Read the code carefully, check for bugs, security issues, and style problems. Be specific about line numbers and provide fix suggestions." \
  --tool '{"type": "agent_toolset_20260401"}'

The response comes back as JSON with the agent ID and version. I like to extract just the ID for scripting:

# Extract the agent ID
AGENT_ID=$(ant beta:agents create \
  --name "Code Reviewer" \
  --model claude-sonnet-4-6 \
  --system "You are a senior code reviewer." \
  --tool '{"type": "agent_toolset_20260401"}' \
  --transform id --format raw)

echo "Created agent: $AGENT_ID"

The --transform flag uses GJSON syntax to pluck a specific field from the response, and --format raw strips the quotes. This is one of the CLI's best features for scripting.

Step 2: Create an Environment

ENV_ID=$(ant beta:environments create \
  --name "python-dev" \
  --pip-packages '["pytest", "ruff", "mypy"]' \
  --networking unrestricted \
  --transform id --format raw)

echo "Created environment: $ENV_ID"

Environments define what's pre-installed in the container. I'm giving this one Python linting tools since it's a code review agent. The unrestricted networking flag lets the agent fetch external resources if needed.

Step 3: Start a Session

SESSION_ID=$(ant beta:sessions create \
  --agent-id "$AGENT_ID" \
  --environment-id "$ENV_ID" \
  --transform id --format raw)

echo "Started session: $SESSION_ID"

Step 4: Send a Message and Stream the Response

# Send a review request
ant beta:sessions:events send \
  --session-id "$SESSION_ID" \
  --type user.message \
  --content-type text \
  --content-text "Review this Python function for bugs:

def divide(a, b):
    return a / b
"

# Stream the agent's response in real-time
ant beta:sessions stream --session-id "$SESSION_ID"

The stream command opens a real-time SSE connection to the session. You'll see the agent's thinking, tool calls (it might run the code through ruff), and its final review - all printed to your terminal as they happen.

Tip: Want to explore the response interactively? Replace --format raw with --format explore on any command to open the TUI explorer. It lets you navigate nested JSON with arrow keys - really useful when debugging agent responses.

YAML Version Control for Agents

This is the ant CLI's best feature, and the one I haven't seen anyone write about yet. Instead of passing flags inline, you can define agents and environments as YAML files, check them into Git, and deploy through your CI pipeline.

# code-reviewer.agent.yaml
name: Code Reviewer
model: claude-sonnet-4-6
system: |
  You are a senior code reviewer. Read the code carefully,
  check for bugs, security issues, and style problems.
  Be specific about line numbers and provide fix suggestions.
tools:
  - type: agent_toolset_20260401
    configs:
      - name: web_fetch
        enabled: false

# code-reviewer.environment.yaml
name: python-dev
pip_packages:
  - pytest
  - ruff
  - mypy
networking: unrestricted

Now you can create the agent directly from the file:

# Create from YAML
ant beta:agents create < code-reviewer.agent.yaml

# Update an existing agent (version is required for safety)
ant beta:agents update \
  --agent-id "$AGENT_ID" \
  --version 1 \
  < code-reviewer.agent.yaml

The versioning requirement matters. When you update an agent, you must pass the current version number. If someone else updated it since you last pulled, the command fails rather than silently overwriting. It's optimistic concurrency control - the same pattern you'd find in Kubernetes or Terraform.

This YAML approach is where the ant CLI really shines for teams. Your agent configs live in the same repo as your application code, go through pull request review, and deploy through the same pipeline. I wrote more about the broader Managed Agents architecture in my Managed Agents vs Agent SDK comparison, but the YAML workflow is what makes the CLI my preferred interface.

According to the official CLI docs, Anthropic designed the YAML workflow specifically for GitOps-style agent management. If you're already doing infrastructure as code, this slots right in.

ant CLI vs curl vs SDK - Why Use the CLI?

You can hit the Managed Agents API three ways: raw HTTP with curl, a language SDK (Python, TypeScript, Go, etc.), or the ant CLI. Each has its place.

Feature	curl	ant CLI	Python SDK
Setup time	None	2 minutes	5 minutes
JSON body authoring	Manual	Typed flags / YAML	Typed objects
Auto-pagination	Manual	Built-in	Built-in
File references	Manual base64	`@path` syntax	File objects
Response filtering	Pipe to jq	`--transform`	Code
Shell scripting	Verbose	Ergonomic	Requires Python
CI/CD fit	OK	Excellent	Good
Best for	Quick tests	Ops / automation	App integration

The ant CLI sits in a sweet spot. It's faster than writing curl commands by hand (no JSON body construction, no header management), and lighter than pulling in a full SDK when you just want to script some agent operations. For anything that lives in a shell script or CI workflow, it's the right tool.

If you're building an application that embeds agent interactions - a web app, a Slack bot, a data pipeline - use the SDK. The ant CLI is for the operational layer: provisioning agents, rotating credentials, monitoring sessions, deploying config changes.

Scripting and Automation Patterns

Here are a few patterns I've found useful when automating agent workflows with the ant CLI.

Extract IDs from Create Commands

#!/bin/bash
set -euo pipefail

# Create agent and capture the ID
AGENT_ID=$(ant beta:agents create \
  < agents/reviewer.agent.yaml \
  --transform id --format raw)

# Create environment and capture the ID
ENV_ID=$(ant beta:environments create \
  < agents/reviewer.environment.yaml \
  --transform id --format raw)

echo "Agent: $AGENT_ID"
echo "Environment: $ENV_ID"

# Store for later use
echo "AGENT_ID=$AGENT_ID" >> .env.agents
echo "ENV_ID=$ENV_ID" >> .env.agents

GitHub Actions Deployment

name: Deploy Agents
on:
  push:
    branches: [main]
    paths: ['agents/**']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install ant CLI
        run: |
          curl -fsSL \
            "https://github.com/anthropics/anthropic-cli/releases/download/v1.2.1/ant_1.2.1_linux_amd64.tar.gz" \
            | sudo tar -xz -C /usr/local/bin ant

      - name: Update agent config
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          ant beta:agents update \
            --agent-id "${{ vars.AGENT_ID }}" \
            --version "${{ vars.AGENT_VERSION }}" \
            < agents/reviewer.agent.yaml

List All Agents and Environments

# List agents in a readable table
ant beta:agents list --format yaml

# List environments with just names and IDs
ant beta:environments list --transform "data.#.{id,name}" --format yaml

# Check session status
ant beta:sessions retrieve \
  --session-id "$SESSION_ID" \
  --transform status --format raw

The --transform flag accepts full GJSON path syntax. You can filter arrays, project specific fields, and even do conditional extraction. It's much cleaner than piping to jq for simple extractions, though for complex transformations I still reach for jq.

What Tools Can Managed Agents Use?

When you include {"type": "agent_toolset_20260401"} in your agent config, it gets access to a standard set of tools: bash, read, write, edit, glob, grep, and web_fetch. All are enabled by default.

You can selectively disable tools you don't want the agent to have. For a read-only code review agent, you might disable write and edit:

# readonly-reviewer.agent.yaml
name: Read-Only Reviewer
model: claude-sonnet-4-6
system: Review code without modifying it.
tools:
  - type: agent_toolset_20260401
    configs:
      - name: write
        enabled: false
      - name: edit
        enabled: false
      - name: web_fetch
        enabled: false

Or flip the default and whitelist only what you need:

tools:
  - type: agent_toolset_20260401
    default_config:
      enabled: false
    configs:
      - name: bash
        enabled: true
      - name: read
        enabled: true

Agents can also connect to external MCP servers for tools beyond the built-in set. If you've built a custom MCP server, a managed agent can use it by adding an mcp_servers block to the agent config.

Frequently Asked Questions

What is the ant CLI from Anthropic?

The ant CLI is Anthropic's official command-line client for the Claude API. Written in Go, it provides a resource-based command structure for managing agents, environments, and sessions. It supports typed flags, YAML input, auto-pagination, and multiple output formats including an interactive TUI explorer.

How do I install the ant CLI on macOS?

Install via Homebrew: run brew install anthropics/tap/ant, then clear the macOS quarantine flag with xattr -d com.apple.quarantine "$(brew --prefix)/bin/ant". Set your ANTHROPIC_API_KEY environment variable and verify with ant --version.

What is the difference between the ant CLI and Claude Code?

Claude Code is an interactive agentic coding assistant that runs in your terminal and uses a subscription. The ant CLI is a programmatic API client for managing Managed Agents resources, uses an API key, and is built for scripting and CI/CD automation. They're complementary - Claude Code can even shell out to ant commands.

How much does it cost to run a managed agent session?

Sessions cost $0.08 per session-hour, billed to the millisecond. Idle time is free. You also pay standard Claude API token rates on top. A typical 1-hour coding session with Opus costs roughly $0.70 total including both tokens and session runtime.

Can I version control agents with the ant CLI?

Yes. Define agents as YAML files (e.g. reviewer.agent.yaml), check them into Git, and deploy via CI. Use ant beta:agents create to create from YAML and ant beta:agents update with the version flag to push updates. This gives you full GitOps for agent configurations.

Can managed agents connect to MCP servers?

Yes. Agents support remote MCP server connections via the --mcp-server flag. You specify the server URL and name, then add an mcp_toolset tool entry referencing that server. This lets agents use tools from GitHub, Slack, or custom MCP servers you've built.

How do I use the ant CLI in CI/CD pipelines?

Define agents and environments as YAML files in your repo. In CI, use ant beta:agents create < agent.yaml to provision and ant beta:agents update to deploy changes. The --transform flag extracts IDs for scripting, and --format controls output parsing.

What tools are available to managed agents?

The agent_toolset_20260401 built-in toolset includes bash, read, write, edit, glob, grep, and web_fetch. You can enable or disable individual tools, or disable all by default and whitelist specific ones. Agents can also connect to external MCP servers for custom tool integrations.

Read the full tutorial with interactive code examples and component-based layout on the original post: Getting Started with the ant CLI on avinashsangle.com.

Wrapper Classes in Java – A Simple Guide

Jayashree — Wed, 22 Apr 2026 05:01:29 +0000

When we start learning Java, we mostly work with primitive data types like int, char, double, etc. These are fast and efficient. But at some point, we run into situations where primitives alone are not enough. That’s where wrapper classes come into the picture.

What is a Wrapper Class?

A wrapper class is used to convert a primitive data type into an object.

In simple terms, it “wraps” a primitive value inside an object.

For example:

int → Integer
char → Character
double → Double
boolean → Boolean

So instead of working with raw values, we can work with objects.

Why Do We Need Wrapper Classes?

You might wonder — why not just use primitives?

Good question. Here are the main reasons:

1. Collections work only with objects

Java collections like ArrayList cannot store primitive types.

ArrayList<int> list;   //  Not allowed
ArrayList<Integer> list; //  Allowed

So we use wrapper classes to store values in collections.

2. Utility Methods

Wrapper classes provide useful methods like:

Integer.parseInt("123");   // converts String to int
Double.valueOf("10.5");    // converts String to Double

These methods make data conversion easy.

3. Object-Oriented Features

Sometimes we need objects instead of primitives—for example, when working with APIs, frameworks, or generics.

Wrapper classes help us follow object-oriented programming concepts.

Autoboxing and Unboxing

Java automatically converts between primitives and wrapper classes.

Autoboxing (primitive → object)
Integer num = 10; // int → Integer

Unboxing (object → primitive)
Integer num = 10;
int value = num; // Integer → int

This makes coding easier and cleaner.

Where Are Wrapper Objects Stored?

Primitive values → stored in stack memory
Wrapper objects → stored in heap memory
Reference variables → stored in stack

Example:

Integer a = 10;

Here:

a is stored in stack
The actual object (10) is stored in heap
Special Case: Integer Caching

Java caches values between -128 to 127.

Integer x = 100;
Integer y = 100;

System.out.println(x == y); // true

Because Java reuses the same object from memory.

But:

Integer x = 200;
Integer y = 200;

System.out.println(x == y); // false

Here, new objects are created.

Final Thoughts

Wrapper classes play a very important role in Java. Even though primitives are faster, wrapper classes give flexibility, especially when working with collections, APIs, and object-based operations.

If you are preparing for interviews, understanding wrapper classes, autoboxing, and memory behavior is a must.

How I Saved a Mumbai CA Firm ₹18 Lakh/Year by Automating GST Invoice Reconciliation

Archit Mittal — Wed, 22 Apr 2026 04:57:08 +0000

Last month, I worked with a mid-sized CA firm in Andheri, Mumbai. They had 4 junior accountants whose full-time job was reconciling GSTR-2B data with purchase invoices for 80+ clients. Each reconciliation took 6-8 hours per client per month.

The math was brutal: 4 accountants × ₹35,000/month × 12 months = ₹16.8 lakh/year in salaries, plus ₹1.2 lakh in infrastructure and overhead. Total: ₹18 lakh/year of manual work that a 200-line Python script could replace.

Here is exactly how I did it.

The Problem

Every month, Indian businesses running on GST deal with two data sources:

GSTR-2B JSON from the GST portal — purchases reported by your suppliers.
Purchase register exported from Tally, Zoho Books, Busy, or plain Excel.

An accountant then matches invoice numbers, GSTIN, taxable values, and tax amounts row by row. Mismatches — wrong GSTIN, missing invoices, ITC eligibility flags — get flagged manually. It is tedious, error-prone, and scales linearly with client count.

The firm's owner told me plainly: "We quote ₹5,000/client for monthly reconciliation. We spend ₹8,000 worth of accountant hours on it. Every new client makes us less profitable."

That was the unit economics problem I needed to fix.

The Solution: A 3-Part Python Pipeline

I built a three-step pipeline that runs in about 4 minutes per client instead of 8 hours.

Step 1: Parse GSTR-2B JSON

The JSON from the GST portal is nested. Flatten it into a reconciliation-ready DataFrame:

import json
import pandas as pd
from pathlib import Path

def parse_gstr2b(json_path: Path) -> pd.DataFrame:
    """Flatten GSTR-2B JSON into a reconciliation-ready DataFrame."""
    with open(json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    rows = []
    b2b_section = data.get('data', {}).get('docdata', {}).get('b2b', [])

    for supplier in b2b_section:
        gstin = supplier.get('ctin', '')
        supplier_name = supplier.get('trdnm', '')

        for invoice in supplier.get('inv', []):
            rows.append({
                'supplier_gstin': gstin,
                'supplier_name': supplier_name,
                'invoice_no': invoice.get('inum', '').strip().upper(),
                'invoice_date': invoice.get('dt', ''),
                'taxable_value': float(invoice.get('val', 0)),
                'igst': float(invoice.get('iamt', 0)),
                'cgst': float(invoice.get('camt', 0)),
                'sgst': float(invoice.get('samt', 0)),
                'itc_eligible': invoice.get('itcavl', 'Y') == 'Y',
            })

    return pd.DataFrame(rows)

Step 2: Normalize the Purchase Register

Client data comes in 15 different formats. Column names are inconsistent across Tally, Zoho, Busy, and handcrafted Excel sheets. I normalize everything to the same schema before reconciling:

def load_purchase_register(file_path: Path) -> pd.DataFrame:
    """Handle Tally exports, Zoho CSVs, and client Excel files."""
    if file_path.suffix == '.csv':
        df = pd.read_csv(file_path)
    else:
        df = pd.read_excel(file_path, sheet_name=0)

    # Column aliases seen across 80+ clients
    alias_map = {
        'GSTIN': 'supplier_gstin',
        'Party GSTIN': 'supplier_gstin',
        'Vendor GSTIN': 'supplier_gstin',
        'Invoice Number': 'invoice_no',
        'Bill No': 'invoice_no',
        'Bill Number': 'invoice_no',
        'Taxable Amount': 'taxable_value',
        'Basic Amount': 'taxable_value',
        'IGST Amount': 'igst',
        'CGST Amount': 'cgst',
        'SGST Amount': 'sgst',
    }

    df = df.rename(columns={k: v for k, v in alias_map.items() if k in df.columns})
    df['invoice_no'] = df['invoice_no'].astype(str).str.strip().str.upper()

    numeric_cols = ['taxable_value', 'igst', 'cgst', 'sgst']
    for col in numeric_cols:
        if col in df.columns:
            df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)

    return df

Step 3: Reconcile and Flag Mismatches

This is the heart of the script. Outer-join both datasets on GSTIN and invoice number, then tag every row with a reconciliation status:

def reconcile(gstr2b: pd.DataFrame, purchase: pd.DataFrame, tolerance: float = 1.0) -> pd.DataFrame:
    """Match on GSTIN + invoice_no. Flag tax differences above tolerance."""
    merged = gstr2b.merge(
        purchase,
        on=['supplier_gstin', 'invoice_no'],
        how='outer',
        suffixes=('_2b', '_book'),
        indicator=True,
    )

    def classify(row):
        if row['_merge'] == 'left_only':
            return 'MISSING_IN_BOOKS'
        if row['_merge'] == 'right_only':
            return 'MISSING_IN_2B'

        diff_igst = abs(row.get('igst_2b', 0) - row.get('igst_book', 0))
        diff_cgst = abs(row.get('cgst_2b', 0) - row.get('cgst_book', 0))
        diff_sgst = abs(row.get('sgst_2b', 0) - row.get('sgst_book', 0))

        if max(diff_igst, diff_cgst, diff_sgst) > tolerance:
            return 'TAX_MISMATCH'

        diff_taxable = abs(
            row.get('taxable_value_2b', 0) - row.get('taxable_value_book', 0)
        )
        if diff_taxable > tolerance:
            return 'VALUE_MISMATCH'

        return 'MATCHED'

    merged['status'] = merged.apply(classify, axis=1)
    return merged

The Orchestrator

A small driver wraps everything into an Excel report the accountant can email to the client:

def run_reconciliation(client_code: str, month: str):
    base = Path(f'/clients/{client_code}/{month}')

    gstr2b = parse_gstr2b(base / 'gstr2b.json')
    purchase = load_purchase_register(base / 'purchase_register.xlsx')
    result = reconcile(gstr2b, purchase)

    summary = result['status'].value_counts().to_dict()
    output_path = base / f'reco_{client_code}_{month}.xlsx'

    with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
        result.to_excel(writer, sheet_name='Full_Reconciliation', index=False)
        for status in ['MISSING_IN_BOOKS', 'MISSING_IN_2B', 'TAX_MISMATCH']:
            subset = result[result['status'] == status]
            subset.to_excel(writer, sheet_name=status, index=False)

    print(f'{client_code} {month}: {summary}')
    return output_path

Drop this into a cron job, point it at a folder structure like /clients/ABC123/2026-03/, and you have a nightly reconciliation run for every client.

The Results — 60 Days Later

After running this pipeline across all 80 clients for two months:

Metric	Before	After
Hours per client / month	7 hrs	15 min
Accountants needed	4	1 (review only)
Monthly labour cost	₹1.4 lakh	₹45,000
Error rate	4-6%	under 0.5%
Client turnaround	3-5 days	Same day

Three of the four junior accountants were not laid off — they were redeployed to higher-value advisory work (ITR-3 filings, tax planning, GST notice responses) at ₹60,000/month. A real upgrade for them, and higher revenue per head for the firm.

Annual savings: approximately ₹18 lakh. Script cost: one weekend of my time, plus ₹0/month in infra (it runs on their existing laptop via a Windows Task Scheduler job).

Gotchas I Hit

A few things that tripped me up the first time and are worth calling out:

Invoice number normalization is the hardest part. Suppliers write "INV-001", "INV/001", "Inv 001", and "invoice 1" for the same bill. On top of the .strip().upper() normalization, I added a difflib.SequenceMatcher fuzzy-match layer with a 0.85 cutoff for leftover unmatched rows. It caught another 3% of matches that would otherwise have been false negatives.
Rounding differences in CGST/SGST. Tally and the GST portal occasionally round in opposite directions. A ₹0.50 tolerance on tax heads removes about 90% of false mismatches.
Credit notes live in a different JSON section. They are under cdnr (credit/debit notes for registered) inside GSTR-2B, not b2b. Parse them separately and flip the sign.
ITC ineligibility flags under Rule 42/43 are not always set correctly by suppliers. The script flags these for human review rather than auto-accepting — human judgment still matters here.

Who Can Use This Today

If you run or work at a CA firm, a tax consultancy, or any business with 20+ vendor invoices per month, this pipeline pays for itself in week one. The full production script is around 200 lines. Swap pandas for polars if you are processing 100,000+ rows per month.

The pattern generalizes. Any reconciliation that compares two structured data sources is a 1-2 day Python project that can eliminate a full-time role:

Bank statements vs. books of accounts
Payroll register vs. PF/ESI challans
Sales register vs. e-way bills
Shopify/Amazon settlement reports vs. GSTR-1

India has roughly 1.4 million CA firms and tax consultants. Most of them are still doing this by hand. The tooling gap is staggering — and the ROI on closing it is immediate.

If you try this and run into trouble, the three places things usually break are: invoice number cleaning, JSON schema drift when the GSTN portal updates, and the pd.read_excel engine choice for large files (use openpyxl for .xlsx, xlrd==1.2.0 for legacy .xls).

Ship it on Monday. Save ₹1 lakh by Friday.

I'm Archit Mittal — I automate chaos for businesses. Follow me for daily automation content.

Claude Code Routines: Put Your Laravel Workflows on Autopilot

Hafiz — Wed, 22 Apr 2026 04:45:27 +0000

Originally published at hafiz.dev

The problem with most AI coding workflows is they stop when you do. You close your laptop, the session ends. You're asleep, nothing runs. You come back Monday morning to a pile of unreviewed PRs and no idea whether Friday's deploy is healthy.

Claude Code Routines changes that. They run on Anthropic-managed cloud infrastructure, which means the session keeps going whether your machine is on or not. You write the prompt once, wire up a trigger, and the work happens in the background.

This is a practical guide to getting Routines set up on a real Laravel project. Five concrete use cases, actual prompts, and the gotchas you'll run into before you do.

What Routines are (and what they're not)

A Routine is a saved Claude Code configuration: a prompt, one or more GitHub repositories, and optional MCP connectors, packaged together and triggered automatically. Each run creates a full Claude Code cloud session on Anthropic's infrastructure. Claude clones your repo, does the work, and pushes to a claude/-prefixed branch.

Three things are worth knowing upfront.

First, Routines are different from /loop and Desktop scheduled tasks. /loop runs prompts inside your current terminal session and dies when you close it. Desktop scheduled tasks run on a schedule but need your machine to be on and Claude Code Desktop open. Routines are the only option that runs fully unattended on cloud infrastructure.

Second, this feature is currently in research preview. Behavior, the API shapes, and rate limits may change. That said, it's available right now on Pro, Max, Team, and Enterprise plans with Claude Code on the web enabled at claude.ai/code.

Third, Routines run fully autonomously. No approval prompts during a run. Whatever you write in the prompt is what runs. This is meaningfully different from a normal Claude Code session where you can steer mid-task. If you've used Claude Code Channels to send commands remotely, think of Routines as the version that runs without you sending anything at all.

Option	Where it runs	Machine required?	Survives closing terminal?
`/loop`	Local terminal	Yes	No
Desktop scheduled task	Your machine	Yes	No
Routine	Anthropic cloud	No	Yes

The three trigger types

Every Routine needs at least one trigger. You can also stack them on the same Routine.

Schedule triggers run on a recurring cadence. Hourly is the minimum interval. Daily, weekdays, and weekly are the built-in presets. For something like "every two hours" or "first Monday of the month," you pick the closest preset in the form and then run /schedule update in the CLI to set a specific cron expression after creation.

API triggers give the Routine a dedicated HTTP endpoint. POST to it with a bearer token and optionally pass a text field for run-specific context. This is what makes Routines composable with the rest of your stack: your deploy pipeline, your alerting system, a webhook from Sentry. Any service that can make an authenticated HTTP request can trigger a Routine.

GitHub triggers react to repository events automatically. A PR is opened. A release is published. A labeled PR gets a new commit pushed. You add filters to narrow which events fire: base branch equals main, is draft is false, author contains a specific username.

One Routine can use multiple triggers. A code review Routine might run nightly (for anything opened the day before), fire on every new PR, and be callable via API from your CI pipeline. All three wired to the same prompt.

View the interactive diagram on hafiz.dev

Five Laravel use cases worth setting up

1. Nightly PR review

The most immediately useful Routine for any active Laravel project. Claude reviews all open PRs opened in the last 24 hours, runs your Pest test suite, flags anything touching auth or database migrations, and leaves inline comments.

Prompt to use:

Review all open pull requests in this repository that were opened in the last 24 hours and have no reviewer assigned.

For each PR:
- Run the Pest test suite and report any failures
- Check that migrations are reversible and include both up() and down() methods
- Flag any raw queries that bypass Eloquent
- Check that jobs implement ShouldQueue and define both $tries and $timeout
- Flag any use of env() outside of config files
- Leave inline review comments for issues found
- Add a summary comment listing all issues, or confirming the PR is clean

Do not approve the PR. Add a "needs-changes" label if any issues are found, and "passed-ai-review" if clean.

Set a schedule trigger for every weekday at 8:00 AM. You start the morning with feedback already posted. Human reviewers can focus on architecture instead of catching env() in the wrong place.

2. Queue health check

Horizon is great but it doesn't catch everything. A nightly Routine can run queue diagnostics on your Laravel project and ping you only when something is actually wrong, not just generate noise.

Using the environment variables available in this session, run the following checks:

1. Run php artisan queue:monitor against all configured queue drivers
2. Check the failed_jobs table for any entries created in the last 24 hours
3. Hit the /horizon/api/stats endpoint and verify Horizon is running and workers are active
4. Check the application log for any CRITICAL or ERROR entries from the last 24 hours

If all checks pass, exit without posting anything.
If any check fails, post a message to the #alerts Slack channel with the failure details and the exact artisan commands to fix it.

You'll need a Slack MCP connector configured and your environment credentials set as environment variables in the cloud environment. For a full list of queue-related Artisan Commands, the reference page is worth bookmarking when you're building out the prompt.

3. Automated code review on PR open

Set a GitHub trigger to fire on pull_request.opened with one filter: is draft is false. This catches every non-draft PR the moment it's opened and runs your team's checklist before a human reviewer even looks at it.

A new pull request has just been opened. Apply our Laravel code review checklist:

- New controllers must use the single-action pattern (one public __invoke method only)
- Form Requests used for all validation, never validate() inside controllers
- No env() calls outside of config files
- No missing $fillable on new Eloquent models
- All new jobs implement ShouldQueue and define $tries and $timeout
- Flag any database queries inside loops (N+1 problem) with the exact file and line
- No direct use of DB::statement() or DB::select() without a comment explaining why

Leave an inline comment for each violation. Post a summary comment at the bottom of the PR. Add label "passed-ai-review" if clean, or "needs-changes" if violations were found. Do not approve or request changes on the PR directly.

The filter matters here. is draft: false means the Routine only fires on PRs that are actually ready for review. You don't want it running every time someone pushes a commit to a draft.

4. Post-deploy smoke test via API

Wire your CD pipeline to trigger a Routine every time a production deploy completes. The Routine runs smoke checks against the new build and posts the result to your release channel.

The API trigger gives you a text field you can use to pass deploy context. From your deploy script:

curl -X POST https://api.anthropic.com/v1/claude_code/routines/trig_01XXXXX/fire \
  -H "Authorization: Bearer YOUR_ROUTINE_TOKEN" \
  -H "anthropic-beta: experimental-cc-routine-2026-04-01" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"text": "Deploy complete. SHA: abc123. Environment: production."}'

Note: the bearer token here is your Routine-specific token, not your Anthropic API key. Generate it from the API trigger setup in the web UI. It's shown once, so store it in your secrets manager immediately.

The Routine prompt can reference the deploy context passed via text:

A production deploy has just completed. The deploy details are in your session context.

Run the following smoke checks:
1. Hit the /health endpoint and verify a 200 response
2. Run php artisan about to confirm the application is responding
3. Run php artisan queue:monitor and report queue status
4. Check the error log for any new CRITICAL entries in the last 5 minutes

Post results to the #deployments Slack channel. Include the deploy SHA from the context. Mark as PASS if all checks succeed, FAIL with details if any check fails.

5. Weekly documentation drift detection

Docs get stale. A weekly Routine that scans merged PRs, compares changed methods against your /docs directory, and opens update PRs when it finds drift handles this automatically.

Scan all pull requests merged in the last 7 days.

For each merged PR:
1. Identify which PHP files changed
2. Check whether the changed public methods or classes are referenced in the /docs directory
3. If documentation references a changed method but looks outdated based on the diff, open a PR against the docs branch with a suggested update

Skip PRs that only changed tests, migrations, config files, or frontend assets. Only flag documentation that references changed public-facing methods or API endpoints.

Schedule it for Sunday at midnight. By Monday morning you have doc update PRs queued, not a manual task sitting in someone's backlog.

Setting up your first Routine

The fastest path is through the web UI. Go to claude.ai/code/routines and click New routine.

Give it a descriptive name. "Nightly PR Review" is better than "Routine 1." Write the prompt. This is the most important part: the Routine runs without you in the loop, so the prompt must be explicit about what to do and what success looks like. Vague prompts produce vague results, and there's no one watching to redirect them.

Select your GitHub repository. Claude clones it fresh at the start of every run, starting from the default branch.

Pick an environment. The Default environment works for most cases. If your Routine needs to call external APIs or read secrets like Sentry tokens or Slack webhooks, create a custom environment first and set those values as environment variables there.

Add your trigger. For a scheduled Routine, pick the frequency. Times are set in your local timezone and converted automatically, so "9:00 AM" fires at 9:00 AM wherever you are, not in some UTC offset you have to calculate.

Review the connectors. All connected MCP connectors are included by default. Remove anything the Routine doesn't actually need. A Routine that only reviews code and opens PRs has no reason to have Linear or Google Drive in scope.

Click Create. Hit Run now on the detail page to test it immediately without waiting for the next scheduled time.

From the CLI, run /schedule in any Claude Code session to create a Routine conversationally. Useful when you know exactly what you want and don't want to click through the web UI. /schedule list shows all your Routines, /schedule update changes one, and /schedule run triggers it immediately.

Branch permissions: the default that catches people

By default, Routines can only push to branches prefixed with claude/. This is intentional. An autonomous agent creating commits on main or develop is risky if the prompt isn't perfectly scoped.

When you add a repository to a Routine, there's an Allow unrestricted branch pushes toggle. Leave it off unless you have a specific need. The claude/ prefix keeps automated work clearly identifiable and makes cleanup straightforward if something goes sideways.

If your Routine is creating PRs that look right but fails on push, this is almost certainly the reason. Enable unrestricted pushes for that repo in the Routine's settings.

The flip side: PRs created by a Routine appear under your GitHub identity. Commits carry your username. Slack messages sent by a Routine's connector use your Slack account. The Routine acts as you, not as a bot account.

Plans and limits

Routines are available on Pro, Max, Team, and Enterprise plans. They draw from your regular Claude Code subscription usage the same way interactive sessions do. There's also a daily cap on how many Routine runs can start per account, visible at claude.ai/settings/usage.

If you hit the daily cap, additional runs are rejected until the window resets. On Team and Enterprise plans with extra usage enabled, Routines continue on metered overage instead.

GitHub event triggers also have per-routine and per-account hourly caps during the research preview. Events beyond the limit are dropped until the window resets. Worth keeping in mind if you're setting up a trigger on a high-volume repository.

When to use GitHub Actions instead

Routines are not a replacement for CI/CD. Running tests on every push, deploying to staging on merge, enforcing security checks before a PR can be merged, anything that needs to block a developer workflow belongs in GitHub Actions. It integrates with branch protections, runs in your own infrastructure, and has native visibility in the PR UI.

Routines are better for background work that doesn't need to gate anything. Review, triage, documentation updates, monitoring. Think of it as the difference between a gatekeeper (CI/CD) and an assistant handling repetitive work in the background.

Also, Routines run with no approval prompts. That's the point, but it's also a risk. Test any Routine with Run now and review what it actually did before leaving it to run unattended. A badly scoped PR review prompt that opens 30 spurious PRs is not a great Monday morning.

The Claude Code ecosystem post covers where Routines fit alongside other pieces like CLAUDE.md, skills, MCP, and the plugin marketplace if you want the full picture.

FAQ

Do Routines work on private repositories?

Yes. Routines clone your connected GitHub repositories, including private ones, as long as you've granted the necessary access via the web setup flow or /web-setup in the CLI. GitHub event triggers specifically require installing the Claude GitHub App on the repository. Repository access via /web-setup is separate and doesn't install the App automatically.

What's the difference between a Routine and a GitHub Action that calls Claude Code?

GitHub Actions run on GitHub's infrastructure, count against your GitHub Actions minutes, and can gate PRs and deployments through required status checks. Routines run on Anthropic-managed infrastructure and count against your Claude Code subscription. Use GitHub Actions when you need to block something. Use Routines for background work that doesn't need to block anything.

Can I share Routines with teammates?

Not currently. Routines belong to your individual claude.ai account and aren't shared. Everything a Routine does through your GitHub identity or connectors appears as you. For team workflows where multiple people need the same automation, each person sets up their own Routine, or you handle it through GitHub Actions with shared secrets.

Can I pass different context on each API trigger call?

Yes. The optional text field in the API request body is passed to the Routine as run-specific context alongside its saved prompt. Pass anything: a Sentry alert body, a deploy SHA, a list of changed files. The Routine receives it as a literal string, so don't send structured JSON expecting it to be parsed. If you need structured data, serialize it yourself and parse it in the prompt instructions.

What happens when a Routine run fails mid-session?

The run session stays visible at claude.ai/code/routines. You can open it, see exactly what Claude did, and continue the conversation manually if needed. The Routine itself keeps running on future triggers. Only that individual run failed.

Conclusion

Routines flip the default. Instead of Claude Code being a tool you actively drive, it becomes something that works in the background while you're focused on other things, or asleep. The nightly PR review alone is worth the setup time on any project with more than one contributor.

Start with one. Set up the nightly PR review, run it manually a few times to tune the prompt, then leave it running. Once you trust it, you'll think of five more things to automate.

Building a Laravel application that needs architectural review or a second set of eyes on code quality? Get in touch and let's talk about what that looks like.