More from Founder's blog
Binance lost $6.3 billion, a backdoored Claude Code extension went out to developers, and Polymarket was drained through someone else's monitoring script. That was just the last 48 hours. Insane. Here's the full list: Binance lost $6.3 billion. It's the largest crypto theft on record, about four times the size of the Bybit hack from last year. Most of it left in about 20 minutes. The Claude Code extension in Cursor's marketplace was backdoored. Someone published a tampered build under the official extension ID. It added an attacker's SSH key to the machine and set up persistence. It was live for about 11 hours and reached up to 5,000 developers. These are developers, so their laptops have production credentials on them. Polymarket got drained through somebody else's script. Attackers compromised DebugBear, a website performance monitoring service. Its monitoring snippet started serving malicious JavaScript that used logged-in users' sessions to move funds. Over $2 million was taken. DebugBear has asked all of its customers to remove the snippet while it investigates. Hetzner warned customers about a UEFI firmware flaw (CVSS 9.5, 16 years old) in the network boot code that runs before the operating system, and before Secure Boot can do anything about it. It affects their dedicated servers and UEFI cloud VMs. A maximum-severity GitLab flaw is being exploited in the wild, according to CISA. Federal agencies got a few days to fix it. Meanwhile, in the Linux kernel, a TCP bug was quietly re-scored from 5.9 to 9.8, which means unauthenticated remote code execution. As of Thursday, Ubuntu and RHEL still hadn't shipped patched kernels. There's also a 9.3 bug that lets a guest VM read host memory, and a local root bug that CISA says attackers are actively exploiting. The week before that, two critical PHP flaws dubbed "PHP2Shell" allowed unauthenticated remote code execution on basically any server running PHP 5.4 or newer. Governments didn't wait to find out whether they'd been hit. Finland, the Dutch parliament, the Dutch data protection regulator and parts of the Canadian government took their websites offline until they could patch. Around the same time, a backdoored release of LiteLLM (a popular AI gateway library) appeared on PyPI. Japan Airlines and ANA disclosed passenger data leaks, both through Amadeus, a vendor they share. That's one freaking week. Honestly, I need a drink. Falling into a black hole The closer something gets to a black hole, the faster it falls. Gravity gets stronger with every meter, so the acceleration keeps increasing. That's what the security world feels like right now. It's speeding up in both directions. The PHP2Shell bugs were found by independent researchers using AI tools. The same tools help attackers turn a fresh CVE into a working exploit in hours instead of weeks. Defenders are using AI too, to audit code, find bugs before release and patch faster. Both sides are accelerating, and the time between "vulnerability published" and "vulnerability exploited" keeps shrinking. Look at the list again: most of those incidents didn't start with the victim's own code. They started with an extension, a monitoring snippet, a firmware driver, a library or a vendor's booking system. The victim simply trusted something, and that something got compromised. We run a helpdesk, and our customers keep a lot of sensitive stuff in it: employee issues, customer data, passwords people really shouldn't be emailing but do anyway. So here's what we're changing. What we're doing at Jitbit 1. Removing third-party dependencies and subprocessors. No exceptions. The Polymarket attack came from an innocent performance monitoring script. Nothing was wrong with Polymarket's own code. They had simply loaded JavaScript from someone else's server onto their pages, and that someone got hacked. So we're cutting every third-party service we can live without. No more JavaScript error monitoring. Analytics cut down to the bare minimum. If code runs inside your browser session while you're logged into your helpdesk, we want to have written it and to serve it from our own servers. The same goes for subprocessors on the backend: every vendor that touches customer data is one more company whose security we'd have to trust, and we're shrinking that list. Yes, this means giving up some convenience. Error monitoring services are genuinely useful. But "useful" isn't a good enough reason to give a stranger's script access to your support tickets. CORS, CSP, sha-256 hashes for scripts, all the "nice to haves" you've been putting off - are now critical. 2. Patching and monitoring This sounds obvious, and it is. What has changed is how fast we have to do it. A month ago, "patch within a week" was a reasonable policy. Now exploits can show up before the advisory has finished making the rounds. So we watch the advisories ourselves instead of waiting for a monthly maintenance window, and we patch as soon as fixes come out. 3. AI agents that keep attacking our own app If attackers use AI to find holes, we'd better find them first. We run AI agents in a loop that scans the Jitbit codebase and the running app for security problems, over and over again. They don't get bored, and they don't decide that some code is "probably fine" because it hasn't changed in years. Whenever they find something, we fix it, and the loop starts again. 4. Removing anything we don't need Every package, library, server component and open-source tool we have installed is a potential CVE waiting to happen. Look at the UEFI bug: it lived in a PXE network boot driver for 16 years, and most servers never PXE-boot at all. So we're going through all of it: server software, OS packages, dependencies, OSS components. If we can't explain why something is there, it goes. Code that doesn't exist can't be exploited. 5. Blocking everything at the firewall Our firewalls start from "deny all", and we only open what absolutely has to be reachable. If a port doesn't need to be open, it's closed. If a service only talks to one other machine, only that machine can reach it. It's boring, and it means a lot of bugs never get the chance to be exploited, because the attacker can't reach the vulnerable code in the first place. 6. CrowdSec in front of everything We use CrowdSec to block IP addresses with a bad reputation before they even reach our servers. It's crowdsourced: when an IP starts scanning or brute-forcing someone else's servers, it gets flagged, and everyone in the network blocks it. Most of the automated garbage that hits the internet every day (exploit scanners, credential stuffing, bots probing for the latest PHP bug) never gets to us. The honest part Our whole team now spends more time on devops than on coding. That's not how we'd like it to be. We'd rather be shipping features. But we've looked at this week's news, and we don't think we have a choice. We've shipped more security fixes in the last week than we have in the last 6 months. And it will keep speeding up. Stay safe out there.
Here's a situation we hear about from customers all the time. Someone gets hired as an IT support manager. They inherit two techs, a shared inbox (or a ticketing system nobody likes), and a mandate that sounds something like "build us a proper tiered support team." They have six months to show it's working. It's tempting to start shopping for software. But first you need to find out why everyone hates the current setup. A new ticketing system won't help much if the real problem is that nobody knows who's supposed to approve a laptop. Week one: listen more than you change The worst thing a new manager can do is walk in with a 40-slide transformation plan. Nobody has asked for it yet, and you don't know enough to write it. Instead, talk to as many people as you can, and not only in IT. Department heads, the finance team, sales, and especially the executive assistants. Assistants see every IT failure that annoys their boss, and they will tell you exactly what's broken. Ask what people like about how IT works today and what drives them crazy. You'll get a clear priority list surprisingly fast. Then sit down with your own techs. Ask what wastes their time, what they keep fixing over and over, what they'd change if they could. Pick something you can fix for them. Maybe they're chasing the same approval every week, or sharing one spare laptop between three offices. Sort that out before giving them another process to follow. A few more things to do early: Read the old tickets. If there's any history at all (even an email folder) go through a few months of it with the team. Look for repeat issues, common categories and the stuff that takes forever. This is your first real data. Get the brief from your boss in writing. What does "success" look like in six months? What's the budget? What level of maturity are they actually expecting? "A tiered support team" means something very different at 80 employees and at 2,000. Don't make drastic changes without backing. Changing how people ask for help affects the whole company. If leadership hasn't agreed to it, the first person who complains loudly enough will undo it. Record your starting point Before you change anything, save a few numbers. You'll want them when your boss asks what the last six months achieved: how many requests come in per week, through which channels, how long they take to get a first response, how long until they're resolved, and how many get reopened. The numbers will be rough. That's fine. Six months from now, when someone asks whether the new helpdesk made any difference, you want to answer with "first response went from two days to three hours" rather than "it feels better." The metrics that matter for a helpdesk are well known, so you don't need to invent your own. Agree on what the team supports A ticket can sit untouched because everyone assumes another team owns it. Work out where your team's responsibility starts and ends, including the awkward bits: What do we support, what don't we support, and if we don't, who does? When do we support it? Business hours only? Weekends? Is there an on-call rotation, and who pays for it? What's the difference between an incident (something is broken) and a request (I need something new)? They should be handled differently. Who approves things like software purchases, new accounts or access to sensitive systems? Who orders replacement hardware? Is there an asset inventory, and is it up to date? Is anything monitored, or do we find out about outages when users call? Who owns endpoint security, password management and change management? Write down the gaps too, and take them to whoever can make the decision. "We'll work out who's on call when something breaks" is a miserable arrangement for the person whose phone rings. Pick a ticketing tool. Don't build one You need a ticketing system, but you don't need the perfect one. Almost any modern helpdesk will handle what a team of three needs: tickets, email intake, a portal, a knowledge base, basic automation and reports. Pick something within budget that your team can set up in days, not months, and start using it. Resist the temptation to build something custom or to spend a quarter on a giant ITSM rollout. A team of two doesn't need it, and the time you spend configuring is time you're not fixing anything. (Obviously we'd suggest Jitbit Helpdesk, but the advice holds for any tool.) When you set up the portal, keep this in mind: make it simple for the people asking for help, not for the people answering. Your users don't know how IT works. If someone can't log in, they have no idea whether it's the VPN, their password, an expired license or a permission problem. Asking them to pick from 30 categories and route their own ticket to the "Identity & Access" queue guarantees misrouted tickets and annoyed users. Plenty of helpdesks are designed by helpdesk staff for their own convenience, and to the end user they feel almost hostile. Start with one big button: "I need IT help." Let your tier 1 tech read the ticket and decide where it goes. Once you see which requests come in again and again, add a few specific forms for them (new starter, access request, hardware order) and grow it into a proper category structure from real data rather than guesswork. One front door, and stick to it Once the system is live, every request goes through it. Not a DM to your favourite tech, not a hallway conversation, not a "quick question" in the team chat. Otherwise, a tech can spend all afternoon helping people and look idle in your reports. And when they're off sick, nobody knows what they were working on. This will be unpopular for a few weeks, so be consistent but not rude about it. When someone pings a tech directly, the tech logs the ticket on their behalf and replies with the ticket number. After a while people figure out that filing a ticket is faster. It helps a lot if the tool meets people where they already are, for example by letting them open tickets from Microsoft Teams or by email. The same goes for ticket quality. You're allowed to teach users how to ask for help. A ticket that says "the report doesn't work" should get a polite reply asking which report, what parameters, and what the error said. Better still, put those questions on the form with a ticket template. Templates also make patterns much easier to spot, because the same fields get filled in every time. Documentation: make it easy, not perfect If writing up a five-minute fix takes twenty minutes, the docs will always be out of date. Keep the routine notes quick to write. An informal internal knowledge base, owned by the techs. Every time someone solves something non-obvious, they write a quick entry: what the symptoms were, what the actual cause turned out to be, and how they fixed it. Three paragraphs, no formatting rules. If someone hits the same issue again, they add a short note ("seen again on March 4, this time it was the dock firmware"). Let everyone edit everything, keep backups, and stay out of the way. If every troubleshooting note needs your approval, you've given yourself another queue to clear and your techs another reason to put it off. SOPs for the processes that matter. Onboarding a new employee, offboarding someone, handling a lost laptop, escalating a security incident. Write these together with your techs, not for them. You'll get pushback, and the trick is to sit with them and draft the complex ones as a pair. Ask about the steps they usually leave out because "everyone knows that bit." Those are often the ones a new hire gets stuck on. AI can help turn rough notes into a procedure, but the tech still needs to check it before anyone follows it. Keep the docs near the tickets. Documentation spread across file shares, wikis and someone's OneNote is documentation nobody finds. If your helpdesk has a built-in knowledge base, use it, and link articles from the relevant categories and canned responses. A new tech should be able to find the fix without having to know who wrote it. Ticket history also helps when someone says "IT never told us." It's useful to be able to pull up the actual conversation instead of arguing from memory. ITIL: borrow, don't adopt You'll hear a lot of advice to get certified in ITIL and build everything around it. The concepts are valuable: the incident vs request split, problem management (fixing the root cause, not just the symptom), change management, a service catalog. Learn them. (We wrote a short explainer on ITIL vs ITSM if you need a refresher.) But for a team of three supporting a mid-sized company, a full ITIL implementation is mostly paperwork. Take the parts that solve problems you actually have and skip the rest. You can always add more formality as the team grows. Removing it later is much harder. Automate the repetitive stuff Once tickets are flowing through one system, you'll see exactly where the time goes. A few areas are almost always worth automating early: Joiners, movers and leavers. If your HR system talks to your identity provider, most of the employee lifecycle can run automatically. Account creation, group membership, license assignment and, more importantly, account removal when someone leaves. SaaS provisioning. If your apps support SSO and SCIM, user provisioning and deprovisioning can happen without a ticket at all. Software installs. Most MDM tools let you publish a self-service catalog. Approved software shouldn't need a tech. Password resets. Self-service password reset removes a whole category of tickets overnight. Distribution lists and shared mailboxes. A few simple scripts handle most of these. Triage inside the helpdesk. Auto-assign by category, auto-reply with relevant KB articles, escalate tickets that sit too long, close stale ones. See our list of helpdesk automation ideas for more. Keep track of what these changes save you. When you ask for another hire, it helps to show which repetitive jobs you've already automated and what's still taking up the team's time. Set SLAs and show your numbers Once you have a few weeks of real data, define response and resolution targets and present them to business stakeholders. Be specific about what you can promise. "We'll respond within 30 minutes during business hours" tells people something useful. Promising to resolve every critical incident in four hours is harder to defend when you're waiting on a vendor. Our guide to SLA management covers how to set realistic ones, and ticket priority levels are the other half of the same conversation. Ask your users how it's going, too. Your resolution times can improve while people are still frustrated because they never get an update. Share what you heard and what you're changing. "You told us password resets were painful, so we added self-service reset" earns more goodwill than any satisfaction score. Growing into tiers You don't need tiers on day one. With three people, everybody does everything, and that's fine. Tiers start to make sense when the ticket data shows a clear split between quick, repeatable requests and long, specialist investigations, and when the specialists keep getting interrupted by the quick stuff. A typical progression looks like this: Everyone handles everything, but you track which tickets take minutes and which take days. A dedicated first-line person handles intake, routing and the quick fixes, using the knowledge base the team has been building. Everyone else gets fewer interruptions. Formal tier 1 and tier 2, with written escalation rules: what tier 1 must try before escalating, what information they attach, and how quickly tier 2 responds. Specialist queues (infrastructure, applications, security) once the volume justifies it. For a sense of how many people you'll need at each stage, see how big should your IT helpdesk team be. When you hire, hire for character first. You can teach someone Active Directory. Teaching patience, curiosity and the ability to stay calm with an angry user is much harder. We've written more about the skills good helpdesk staff need. Look after the team you have If a tech tells you they're falling behind, look at the queue with them. Work out what can wait, what someone else can take, and whether you need to tell users there's a delay. If admitting they're stuck earns them a lecture, next time you'll find out from an angry user instead. Give the team time to fix the things that keep slowing them down. That might mean leaving a few non-urgent tickets until tomorrow while someone sorts out the deployment script they've been fighting all month. A rough six-month plan These will overlap. Start writing down fixes as soon as you have somewhere to put them, and agree on urgent-ticket expectations early. The months below give you an order to work through, not deadlines to impose on a team you just met. Month 1: talk to everyone, read old tickets, record baseline numbers, fix one quick pain point for your techs, agree on goals and budget with leadership. Month 2: write down your scope, pick a ticketing tool, launch a simple portal with one "get help" button, enforce one front door. Month 3: review the notes you've collected, document the key SOPs with your techs, add the first request forms based on real ticket data. Month 4: automate the obvious things: onboarding and offboarding, password resets, software installs, ticket routing. Month 5: check whether you're meeting your response targets, ask users what's still frustrating them, and pick something to fix. Month 6: compare against your baseline, present the results, and use the data to make the case for the next hire or the first tier split. Six months in, you should be able to show what comes in, who's handling it, and where the team still needs help. You may still have two techs. At least you'll have something better than "we're busy" when you ask for a third.
Every helpdesk vendor now sells "AI". What they actually ship differs a lot. Some offer a chatbot that answers customers before a ticket exists. Some offer a copilot that drafts replies for agents. Others hand you a platform and a consultant's invoice. The pricing models differ too: per seat, per conversation, per "resolution", or a pool of credits that nobody on the buying committee fully understands. We looked at six options, from a free do-it-yourself build to a full enterprise ITSM suite. Each one gets the same treatment: what it does well, where it falls short, and what it costs as of September 2026. Disclosure: this review is published on Jitbit's blog, and Jitbit is one of the products below. We tried to hold it to the same standard as the others, and we list its weaknesses too. Competitor prices come from public pricing pages and recent third-party breakdowns. Vendors change prices often, so check before you sign. How we evaluated Grounding. Does the AI answer from your documentation and ticket history, or from general model knowledge? Coverage. Does it deflect tickets (customer-facing), help agents (agent-facing), or both? Cost predictability. Can you forecast next quarter's bill without a spreadsheet model? Time to value. Days, weeks, or a multi-month implementation project? 1. Homegrown & Free: a Copilot Studio agent grounded on SharePoint Best for: internal IT support in organizations that already run on Microsoft 365. This option gets overlooked because nobody sells it. If your company already lives in Microsoft 365, you can build a decent self-service IT assistant in an afternoon without buying a helpdesk. The recipe is simple: put your end-user documentation on one SharePoint site, point a Copilot Studio agent at it, and publish the agent to Teams, where your employees already spend the day. Here is how to do it well. How to set it up Create a dedicated SharePoint communication site, for example "IT Help". Keep the knowledge the agent will use on this one site, not scattered across team sites. A single, clean source gives better answers than a large, messy one. Write one page per problem. "Reset your VPN token", "Printer on floor 3 shows offline", "Request a new laptop". Use the error message or symptom a user would type as the page title, and put the fix in numbered steps. Retrieval works on chunks of text, so short focused pages beat a 60-page PDF manual. Avoid scanned PDFs and screenshots-only pages, because the agent cannot read text inside images reliably. Check permissions. The agent answers using the identity of the person asking, so it only sees what that person can see in SharePoint. Give all employees read access to the site. Keep admin-only runbooks on a separate site so they never leak into employee answers. Create the agent in Copilot Studio (copilotstudio.microsoft.com). Add the SharePoint site URL as a knowledge source, and keep authentication set to "Authenticate with Microsoft", which SharePoint knowledge requires. Turn off general knowledge. In the agent's generative AI settings, disable the option that lets the model answer from its own general knowledge. You want "I don't know" rather than a confident, invented fix for your internal VPN. Write short instructions. For example: "You are the IT help assistant for Contoso employees. Answer only from the IT Help site. Give numbered steps. If the answer is not in the documentation, say so and link to the ticket form." Add an escalation path. Change the fallback topic so unanswered questions end with a link to your ticket form or IT mailbox. More advanced teams add an agent flow that opens a ticket directly, but each tool call uses extra credits. Publish to Teams and Microsoft 365 Copilot, then pin the agent in Teams for all employees through the Teams admin center. If people have to look for the agent, adoption stays low. Review analytics every week. Copilot Studio shows which questions went unanswered. Each one is a missing SharePoint page. Write it, and the agent improves by the next morning. This loop matters more than anything else on this list. Pros. There is no new vendor, no procurement cycle, and no new login. Employees ask questions in Teams, where they already are. Identity, permissions and compliance come from your existing Microsoft tenant, so security review is short. The knowledge base is ordinary SharePoint pages that anyone in IT can edit, with no proprietary format to migrate later. For the large share of internal tickets that are really "how do I..." questions (password resets, VPN, printers, Wi-Fi, software requests), a well-written site plus a grounded agent can deflect a meaningful share of volume in the first month. Cons. This is a self-service answer engine, not a helpdesk. There is no ticket queue, no SLA tracking, no assignment, no reporting on agent workload, and no audit trail of who fixed what. When the bot can't help, the issue goes to email or a form, and you still need something to manage it. Answer quality depends entirely on the documentation. A thin or outdated SharePoint site produces thin or outdated answers. Copilot Studio's credit-based licensing is also hard to forecast, and agents can be disabled automatically once a tenant goes 25% over its prepaid capacity. It works for employees only. Do not try to turn it into a customer-facing support bot. Price. Effectively free if your users already have Microsoft 365 Copilot licenses. Microsoft does not charge credits when licensed users talk to employee-facing agents, within fair-use limits. Without those licenses, Copilot Studio bills in credits: $200 per month for a pack of 25,000, or $0.01 per credit pay-as-you-go through Azure. A generative answer grounded on a knowledge source costs 2 credits. With the optional tenant-graph grounding it costs 12. In practice, that is roughly two to twelve cents per answer, and a few hundred dollars a month covers a mid-sized company's internal IT questions. The real cost is the staff time to write and maintain the SharePoint pages. You would need that documentation with any tool on this list anyway. 2. Jitbit Helpdesk Best for: mid-sized support and IT teams that want a full ticketing system with AI included, not billed separately. Pros. AI is built into the ticketing workflow, not added as a separate product. An AI assistant panel in every ticket drafts replies grounded on your knowledge base, indexed external documentation, canned responses, and similar closed tickets. It also summarizes long threads, cleans up agent drafts, and turns solved tickets into new KB articles, which helps teams that are just starting a knowledge base. Automation rules can run AI triage on every incoming ticket (sentiment, category and priority in one pass) and can post first-line AI replies either directly to the customer or as internal notes for review. The live chat widget has an AI auto-responder that hands off to a human when the visitor asks for one. For technical teams, the AI can call your own HTTP endpoints or MCP servers, so it can look up an order status or a subscription without an agent. Model choice is unusually open: GPT and Gemini are included, or you can bring your own key for Claude, Azure OpenAI or AWS Bedrock. That matters for data-residency and HIPAA reviews, and Jitbit signs a BAA on its Enterprise plan. It is also one of the few products here that still offers a self-hosted, on-premise edition with the same AI features. Cons. Jitbit is a smaller vendor, and its integration marketplace is much smaller than Freshdesk's or ServiceNow's. Its customer-facing bot is a helpful extra on top of a helpdesk, not a dedicated conversational platform. Teams with very high chat volume in B2C, which is Fin's specialty, will find fewer controls for multi-step procedures and channel orchestration. Like every grounded AI, it only performs as well as the knowledge base behind it. On-premise customers who want semantic search and document indexing must run an extra Docker-based add-on, and they supply their own model API keys. The entry-level Freelancer plan does not include AI credits. Price. Flat plans with no per-resolution or per-session fees: Freelancer $29/month (1 agent), Startup $69/month (4 agents), Company $129/month (7 agents), Enterprise $249/month (9 agents, $29 per extra agent). Annual billing saves about two months. Unlimited AI credits are included from the Startup plan up. For a seven-agent team, that works out to about $18 per agent per month with AI included. On most of the other paid products here, AI alone costs more than that per agent. 3. Fin (by Intercom) Best for: high-volume customer-facing support where deflection rate is the main metric. Pros. Fin is arguably the most capable customer-facing AI agent on the market, and it is the product the rest of the category measures itself against. It handles multi-turn conversations well, follows written "procedures" for multi-step tasks such as refunds or account changes, and works across chat, email, and voice. Importantly, Fin does not require Intercom's helpdesk. It can run on top of Zendesk, Salesforce, Freshdesk, Front, and others, so you can add it to an existing stack without migrating. Its reporting is built around resolution rate, which makes the ROI case easy to present to a CFO. Cons. Outcome-based pricing is fair in theory and hard to budget in practice. Fin counts an "assumed resolution" when a customer simply stops replying after its last answer. That includes customers who gave up. Your bill grows with volume, not with headcount, so a seasonal spike or a product incident that floods support also increases your AI spend. Fin is built for customer-facing deflection. Agent-side features are stronger inside Intercom's own inbox, so standalone deployments on other helpdesks get less of the product. For internal IT support, it is the wrong tool. Price. $0.99 per billable outcome (a resolution, a procedure handoff or a disqualification), and $9.99 per qualified sales lead. Running standalone on another helpdesk has a minimum of 50 outcomes a month. Inside Intercom, you also pay for seats: Essential $29, Advanced $85, or Expert $132 per seat per month on annual billing. A ten-seat Advanced team resolving 2,000 conversations a month pays roughly $2,800, and about 70% of that is Fin. 4. Tidio (with Lyro AI) Best for: small e-commerce stores that mainly need a website chatbot. Pros. Tidio is one of the fastest ways to get an AI chatbot onto a website. Lyro, its AI agent, learns from your FAQ and site content in minutes, and setup takes almost no technical skill. It integrates well with Shopify, WordPress, and the common e-commerce stack, so it can answer order and shipping questions that make up most of a small shop's inbox. The visual Flows builder handles cart-abandonment nudges and lead capture alongside support. For a one- or two-person store, the free tier is enough to try it before paying. Cons. Tidio is chat-first, and the ticketing side is basic. There is little in the way of SLAs, complex routing, asset management, or the reporting a growing support or IT team eventually needs. Lyro is billed by conversation, and the free and Starter plans include only 50 Lyro conversations in total, not per month. After that, it stops answering. The plan structure has a big gap: the jump from Growth to Plus is more than tenfold, with no middle tier. Teams often report that real costs run two to three times the advertised price once AI and Flows add-ons are included. It is not designed for B2B, internal IT, or regulated industries. Price. Starter $29/month, Growth from $59/month (scaling to about $349 depending on volume), Plus $749/month, and Premium from $2,999/month. Lyro AI is a separate add-on starting at $39/month, and Flows costs another $29/month. A typical Growth setup with Lyro and Flows costs around $127/month before overages. Annual billing saves about 17%. 5. Freshdesk (with Freddy AI) Best for: mid-market customer support teams that want a mainstream, feature-complete suite and can live with add-on pricing. Pros. Freshdesk is a mature, full-featured helpdesk with omnichannel support, a large app marketplace, solid automation, and a familiar interface that new agents learn quickly. Freddy AI covers both sides of the job. The Freddy AI Agent deflects questions on chat, email and the web widget. Freddy Copilot helps human agents with reply drafts, summaries, tone adjustment and suggested solutions. Freshworks also sells Freshservice for internal IT, so organizations can standardize on one vendor for both customer and employee support. Cons. AI costs are split across several meters and plan requirements. Copilot is available only on Pro and Enterprise, so Growth customers cannot buy it at any price. The customer-facing AI Agent is billed by session, and unused sessions expire at the end of each billing cycle instead of rolling over. Freshworks raised plan prices in 2026 for the first time in five years and cut the free plan to a six-month program for one or two agents. Model choice and on-premise deployment are not available. Price. Growth $19, Pro $55, Enterprise $89 per agent per month (annual billing). Freddy Copilot adds $29 per agent per month ($35 on monthly billing). The AI Agent includes 500 sessions, then costs $49 per 100 sessions. The realistic entry point for agent-side AI is $84 per agent per month (Pro plus Copilot). A five-agent team on Pro with Copilot and moderate bot usage spends roughly $650-700 a month. 6. ServiceNow (with Now Assist) Best for: large enterprises running IT, HR and facilities service management on one platform. Pros. ServiceNow is the default choice for enterprise ITSM, and its AI benefits from being close to all of that data. Now Assist summarizes incidents, drafts resolution notes, generates KB articles from resolved cases, and powers a Virtual Agent that can complete requests end to end instead of just answering questions. Because it sits on the same platform as the CMDB, change management, and HR and facilities workflows, the AI can act on real records: reset an account, provision software, or open a change request. No other product here offers that level of process depth, governance, and audit trail. In 2026 ServiceNow moved to AI-native tiers, so AI is now included by default rather than sold as a separate SKU. Cons. Cost and complexity. Implementations usually take months and a certified partner, and the platform typically needs dedicated administrators after go-live. Pricing is quote-only and heavily negotiated, so two companies of the same size can pay very different amounts. AI usage now draws from consumption-based "Assist" pools, which adds another capacity figure to forecast and renegotiate. For organizations under about a thousand employees, ServiceNow is usually more platform than they need. Price. There is no public price list. In April 2026, ServiceNow replaced its Standard/Pro/Pro Plus/Enterprise tiers with Foundation, Advanced and Prime, and older SKUs reached end of sale in mid-2026. As a reference point, legacy ITSM Pro licenses were widely reported at around $100-135 per fulfiller per month. Adding Now Assist (Pro Plus) raised that by an estimated 50-60%, to roughly $200-215 per fulfiller per month. Minimum seat commitments, platform fees and implementation services often make the first-year total a six-figure amount. Side-by-side Solution Best fit Pricing model AI included? Copilot Studio + SharePoint Internal IT, Microsoft shops Credits, or free with M365 Copilot licenses Yes (it's only AI, no ticketing) Jitbit SMB and mid-market support and IT Flat monthly plans Yes, unlimited from Startup plan Fin High-volume customer support $0.99 per outcome, plus seats in Intercom It is the product Tidio Small e-commerce Plan plus Lyro conversation add-on Add-on from $39/month Freshdesk Mid-market customer support Per agent, plus Copilot seats and bot sessions Add-on, $29/agent plus sessions ServiceNow Large-enterprise ITSM Quote-only, per fulfiller, plus Assist pools Bundled in 2026 tiers The bottom line Start with the question you're really trying to answer. If you want employees to stop emailing IT about VPN passwords and you already pay Microsoft, build the SharePoint and Copilot Studio agent first. It costs almost nothing, and the documentation you write for it will make any helpdesk you buy later work better. If you need an actual ticketing system with AI included and a predictable bill, Jitbit and Freshdesk are the main choices, and they differ mostly in how AI is charged. If deflecting a large volume of customer chats is the whole goal, Fin sets the standard, as long as you are comfortable with a bill that grows with volume. Tidio fits small online stores. ServiceNow fits organizations large enough to need a service-management platform, with a budget to match. Whatever you choose, AI quality comes from your knowledge base, not the model. Every product here gives better answers with better documentation, so start writing it now.
Our new Microsoft Teams app just passed Microsoft's certification and is live in the Teams Store: Jitbit Helpdesk Bot. Search "Jitbit" in the Teams app store and it's right there - no custom app uploads, no admin-center gymnastics. Unlike our old webhook integration (one-way channel notifications, now deprecated), this is a proper two-way bot: End users create tickets in chat - type new and get a real form with category and priority, or turn any Teams message into a ticket from the "..." message menu. my tickets lists your open requests Technician replies come back to Teams - as cards with an inline answer box, so the whole conversation can happen without opening the helpdesk Channels get actionable ticket cards - @mention the bot, type subscribe, and every new ticket shows up with Take it / Reply / Close buttons. Cards update in place when the ticket changes - whether that happens in Teams or in the web app Setup takes about two minutes: install the app, click "Generate pairing command" on the helpdesk admin page, paste the command into a chat with the bot. Users are matched by their Microsoft 365 email automatically. Self-hosted customers run their own private bot, so ticket traffic never touches our servers. The bot is included with all plans. Details and setup steps: the integration page and the documentation.
More in programming
Helping Scout focus and remember
tl;dr: the Explorer Pattern is one individual or team building a functional implementation that minimizes cross-team and cross-functional impacts as much as humanly possible, and then reconciling the details with other teams after that prototype is completed, accepting that this approach can require very substantial rework to that initial development. Why write this? Imprint previously called this the “Tech-led” or “Engineering-led” development model, but it’s pretty unclear to folks what that means. This writeup provides a more defined term, the “Explorer Pattern”, and explains in more detail how this works. Why do we need to adjust the way we work? Before 2026: Code is expensive, and we design process to minimize implementation and rework In and after 2026: Writing software is extremely cheap, but it’s a wider phenomenon: generating output is effectively-free across many dimensions. Code is nearly free — if we have appropriate constraints. Designs are nearly free — if they follow patterns. Analysis is nearly free — if we’ve instrumented things properly Reworking software is extremely cheap. Historically industry has optimized around avoiding engineering rework because engineering was the highest cost / narrowest constraint. In many companies this was interpreted as writing code being the constraint, which was never true, but many common practices were designed as if that were true (e.g. bringing engineering into problem-solving late “to protect their time”) Working on the system is much more effective than historically if we get automated integration and feedback loops right, e.g. not improving a one-off design but improving the design system. Any place where improving the higher-leverage process is slower than solving the one-off is a bug in our process Explorer Pattern: primary-and-replicas metaphor The easiest metaphor to think about the Explorer Pattern is database replication. Databases like MySQL and PostgreSQL have a primary database, where writes are performed. Every write is verified at that point, and once it’s verified, you know that the writes will flow downstream to various secondary replicas. Those downstream replicas can be delayed but they can’t be wrong because writes are verified upstream. (I’ve resisted the desire to talk about the CAP theorem.) A different model for database design is that used by Dynamo or Cassandra (or MongoDB to a certain extent), where you have a replica set, and have to get an acknowledgement from the majority of the replica set for a write to be strongly consistent. This is a very reliable setup, because it means you can tolerate losing a node, but it also introduces inconsistencies, and on a fixed amount of hardware they tend to be much, much slower than running a primary-secondary setup (or rely on bad performance metrics that don’t fsync to disk to create the illusion of throughput). The Explorer Pattern is the former primary-secondary model, where the vast majority of the work is done by the working individual or team. This makes all work internally consistent because it’s passed through the same small group. It doesn’t, however, mean that the work is perfect. For example, you can always insert data that meets the table’s requirements but is still inherently wrong (e.g. 200 is a valid integer, but it doesn’t mean that my credit limit was supposed to be 200, that depends on the surrounding application logic). Other teams become aware of the changes downstream, not synchronously upfront, and it’s instead the working group’s responsibility to both rationalize approach and create visibility into their work for other teams to engage in a non-blocking fashion. Example: Support for Financial Aggregators A concrete example of this practice at Imprint was rolling out financial aggregator support, e.g. allowing folks to connect to their Imprint powered accounts via Plaid. This has always been something folks want, but it’s particularly important in the realm of agentic commerce where more folks’ agents are analyzing their financial state for them. For this project, one of our engineering leaders (Ron), built the first pass of the feature at a low-burn while understanding the shape of the problem in a private alpha. He chatted through some of the details periodically to keep other teams aware, but it was a bit of a side project. However, once he found the full shape of the problem and had implemented a full solution, we cut the replica-lag across teams down to near-zero, identified and ran through the small number of remaining issues, and shipped it. Like many of our projects this year, it was never officially on a roadmap, and shipped a quality feature that our members have wanted for some time. How to follow the Explorer pattern The rough rules for following the Explorer pattern: Know your goal and sponsor: every initiative ultimately has to have a specific outcome it’s pursuing and a sponsor who’s bankrolling that pursuit. This doesn’t always need to be explicit, especially for smaller projects, but once a project goes beyond ~3 weeks of effort, if you can’t very explicitly identify who the stakeholder is sponsoring your project and they would not enthusiastically agree, then you are likely closer to “lost” than “exploring” Small working group is small: at most 5 people, and preferably smaller. Everyone in the group has to keep the entire project in their head for as long as possible to detect problems and opportunities Small working group is flexible: folks in small working groups have to “find a way to yes” rather than “find a way to no”. Exploring is about uncovering the fundamental shape of a problem rather than pretending we know the fundamental shape Publish progress in a public channel: explorers have to report home with the progress they are making so others are aware. This is both a Linear Project and a Slack channel. Make the narrowest viable changes to what already exists: when we introduce unnecessary changes, we invalidate others’ mental models about how the world works. When we haven’t made those changes with care, we’re not only invalidating others’ mental model, we are creating the expectation that we’ve done it very intentionally for a good reason, which has a chilling effect on others improving them later, which is very expensive, whereas the Explorer pattern depends on being as inexpensive as possible Exercise good judgment to identify reasonable hypotheses: discard bad ideas immediately, and then filter the rest by trying to implement them as quickly as possible. Once you see the shape of the implementation, you can figure out which of the remainders are interesting Hold assumptions constant to avoid getting stuck: the only way to navigate complex ambiguous problems is to hold things constant, even when you know they are imperfect. For example, to do headcount planning we have to know our revenue, to know our revenue we have to forecast it, to forecast it we have to know the day that partners will go live next year. We don’t truly know any of those things, so just anchoring on a plausible guess to unblock us is much more valuable than trying to get them accurate. A little prework is useful, but a lot is just artificial precision that’s a distraction from progress Hold space for being totally wrong: when we move fast, with low information, we always find the way out, but often it’s not the way out we anticipated when we got started. Being open to throwing it all away, and starting a second, third, fourth time Ship all the way to production behind a feature flag: features and products move fast when we get the pieces working every step from frontend to backend to data pulls. This is the first step of exploration. Just make sure it’s behind a feature flag that’s only enabled for internal folks!
Comparing two different ways of work and working environments.
I own an old, cheap TV. It has no Internet connection, no fancy smart features that make you want to install a Pi-hole, and no ask-me-again-later updates. However, it is connected to my own desktop computer through an HDMI cable, so I can watch movies and TV series from the couch. Setting it up used […] The post Making a dumb TV just smart enough appeared first on Quentin Santos.
Five days and 540km on a bike across Kyushu, without a laptop. Notes on the peace of riding all day, convenience store dinners, and Japan's emptying countryside.