Cases

What changed for the people who hired me.

I'm Serhii Kravchenko. I answer for every system on this page: I set the rules, I make the decisions, and I sign off on the result. The code, the design and the documents are written by the agent systems I built and run as my team. I have worked this way full time for two years, and every system leaves with its checks, its written guide and its keys, so nothing depends on me staying in the room. Find your department: every case names whose problem it was.

The first step is a free diagnosis; the first slice comes as a fixed price. Book a call.

Show cases for a department

Work for clients

  1. Keaworld

    banking and crypto payments for businesses · Head of AI on contract, October 2025 to July 2026 · four systems

  2. Keaworld, banking and crypto payments for businesses · the sales and marketing team · Head of AI on contract · early 2026

    A new conference becomes a trusted call list in two days, at a twentieth of the old cost per contact.

    A chain of six stages: collect the lists, clean them into one base, score by a written rule, complete the missing profiles, reach out in two channels, learn from the replies; sales picks who to call before the outreach, and an arrow runs from the last stage back to the scoring.
    Six stages from a conference list to a call list, with replies feeding the rule; a contact costs about ten cents instead of about two dollars. · Open at full size (opens in a new tab)

    The company sells at fintech conferences: thousands of attendees, a few hundred of them worth a call. Attendee lists came from a paid data service, and a person went through the rows by hand deciding who fits, with three vague categories and no order of priority. Nobody could say whether the service's data was right. Finding the duplicates in a new batch took half an hour of someone's time every time, and the useful part of a list was usually ready after the conference, not before it.

    What I decided. I did not hand the question “is this our customer” to a model. Marketing and I wrote the selection rule down: which roles, which kinds of company, which countries count, and how much each weighs. The system scores every attendee by that rule the same way every time; the model is used only to fill a gap on a card, such as finding a profile the data service missed, and it is told that not finding one is better than finding the wrong one. Outreach runs in two channels from the same list, and what comes back, replies and questions, feeds the rule before the next conference. Nine conferences went through it this way.

    What changed. From about $2 to about $0.10 per contact · a new conference list turned into a ready call list in two days · about one message in three got a reply, and about one contact in forty became a hot lead.

    Everything it took over
    • Two outreach channels from one list: messaging active, email built and warmed, ready to launch.
    • Replies and the questions people ask are collected and fed back into the selection rule.
    • Every new list is checked against the company's whole base first, so nobody pays to complete a contact the company already had.
    • On one conference list more than a quarter of the names turned out to be known already.
    • Every attendee is scored by the written rule and sorted by priority.
    • Duplicates are found by a script instead of half an hour by hand per batch.
    • The base is checked automatically before every send, with a backup taken first.
    • Profiles the data service could not find were found for four in ten of the missing ones.
    • Sales gets one ready call list per conference, not the raw attendee list.
    • People who said no or unsubscribed are never written to again.
    • The date of every send is kept, so a contact is not approached twice too soon.

    Safe to rely on. The rule that decides is written down and agreed with marketing, not guessed by a model. Every list is checked automatically before a salesperson sees it. A refusal is final: the contact leaves every future list.

    Sales · Marketing and content

  3. Keaworld, banking and crypto payments for businesses · the marketing team and compliance · Head of AI on contract · spring 2026, running

    A regulated fintech's whole year of articles, 120 of them, written by a team of four agents; the company's output is now limited by how fast people read, not how fast they write.

    Left, one person with the last word and three ready packages, for marketing, for the editors and for compliance; centre, a chain of four agents, planner, plan reviewer, writer and article reviewer, a machine-checks panel beneath them and two loops back to fix the plan and the marked places; a green approval point where the person says yes.
    Who does what: four agents plan, judge, write and check, machine checks sit under both reviewers, and a person reads the ready result and says yes. · Open at full size (opens in a new tab)

    The company had a plan of 120 articles for the year, a site launching in a few weeks and an almost empty blog. One article took a person two or three days, and then someone read it again for compliance, because in this business calling the company a bank is a regulatory problem, not a typo.

    What I decided. People keep the last word and write nothing: marketing gets the plan and then the draft, the editors get the finished article with its check report, and compliance gets every figure with its source. In between, four agents do the work: one plans the article, one judges the plan before a line is written, one writes strictly to the approved plan, and one checks the finished text, with machine checks under both reviewers. The company's only work left is reading and saying yes, so the number of articles is limited by how fast people read, not by how fast anyone writes.

    What changed. The whole year's plan, 120 articles, written and checked · two or three days of a person's work per article before · the limit is now how fast people read, not how fast they write.

    Everything it took over
    • The plan of each article is built before any writing and judged by a second agent, so a mistake is fixed in the plan, not in the text.
    • The draft is written to the company's strategy and terminology, to be found by Google and quoted by AI assistants.
    • Every figure, link, quote and name is checked against the lists the company approved, and a claim with no approved source is dropped rather than invented.
    • Forbidden words and the compliance red lines are caught on every draft, not remembered.
    • Text that sounds like a machine is flagged before a person reads it.
    • The structure is checked against the format of the article.
    • Only trusted outside sources are allowed, regulators and the like, never random blogs and never competitors.
    • A draft that quietly adds a section or a source the plan did not have is caught.
    • After the reviewer's notes, only the marked places are fixed, and the whole article is not rewritten.
    • A record is kept of what was checked on every draft.

    Safe to rely on. The system cannot publish and cannot invent a source. The company's terms, figures, red lines and brand profile stay in a closed repository, and moving a finished article to the blog is a person's step.

    Marketing and content · Legal and compliance

  4. Keaworld · the customer support team · Head of AI on contract · designed spring 2026 · a prototype, not yet in production

    A support assistant for every channel customers write to, answering only from the company's own verified answers and handing the rest to a person. Built as a prototype, not yet in production.

    Two lanes: the support team on the left owning the verified answers and the pass mark; the assistant on the right answering customers only within those answers and handing the rest to a person; a gate between them labelled the exam.
    Who does what: the company writes the answers and the pass mark; the assistant answers only inside them and hands the rest over. · Open at full size (opens in a new tab)

    Customers of a fintech write to support in the site chat, by email, in Telegram, WhatsApp and Instagram, at all hours and in two languages, and most of them ask the same questions. A small team answered by hand, channel by channel, and every question that touched compliance or pricing waited for the right person. Vendors promised an assistant that would take this over, but nobody could say how it would be judged or what it must never say.

    What I decided. I wrote the exam before the assistant. The company's own verified answers became its only knowledge. Its tone, the topics it must hand over and the pass mark were agreed with the marketing lead before it met a customer, and it had to show it works properly in the company's language. Only after it passes does it start answering, in every channel at once. Compliance, legal questions, KYC and large deals always go to a person, and so does anything it does not know. The prototype is built on the company's real answers; the production launch is the company's next step.

    What changed. One assistant for every channel customers write to, at any hour · compliance, legal, KYC and big deals always go to a person · a prototype, not yet in production.

    Everything it took over
    • One assistant answers the routine questions in every channel customers use, site chat, email and messengers, from one set of the company's approved answers.
    • What used to be a separate manual process per channel is one.
    • There is a written list of what it hands to a person: compliance, legal, KYC, big deals, and anything it is not sure about.
    • It makes no promises about timelines, approvals or outcomes, ever.
    • The support team is left with the contracts, the compliance questions and the negotiations.
    • The same exam can be given to any vendor's assistant, so the company is not tied to one.

    Safe to rely on. An assistant that has not passed its exam does not meet a customer. It answers only from the company's own approved answers, says when it does not know, and hands over to a person instead of guessing. This is a prototype: it has not met a real customer yet.

    Customer support · Sales

  5. Keaworld · leadership and senior specialists across departments · onboarding into agent systems, one person at a time · October 2025 to July 2026

    From scattered AI chats to agent systems: the same leaders and senior specialists deliver 30 to 200 percent more, by team.

    Two lanes: on the left the leaders and senior specialists, each with their own real task; on the right the agent system with written rules, memory between sessions and a fixed check of the result; the person keeps it after the sessions.
    Who does what: each person brings their own task; the agent system holds the rules, the memory and the checks, and the person keeps it. · Open at full size (opens in a new tab)

    Everyone in the company used AI, and everyone used it alone: a chat window here, a different model there, prompts kept in personal notes, nothing shared and nothing repeatable. The same task was solved from scratch by every person every time, and the quality depended on who was typing that day.

    What I decided. No group training on a toy example. I sat with each person on their own work, from the C-level to the senior specialists in marketing, lead generation, IT, design and business analysis, and moved that work into an agent system: written rules, memory between sessions, a fixed way to check the result, until it ran without me. I also wrote the company's nine-month plan for bringing AI in, stream by stream. Where a shortcut was tempting, we said no: anything that reaches customers is reviewed by a person, at every stage. Recorded sessions, written guides and my open-source memory kit stayed behind as the setup they keep.

    What changed. Team throughput up 30 to 200 percent depending on the function, the same people in the same week · the marketer who waited weeks for a contractor's data now finds it herself the same day · everyone stayed on the new way of working after the engagement ended.

    Everything it took over
    • Leadership and senior specialists in marketing, lead generation, IT, design and business analysis, each onboarded on their own task.
    • The marketer keeps a written guide for the search she now runs herself.
    • Social posts are drafted by AI in the company's own rubrics, reviewed and approved by a person, with the final edit saved back so the next draft is better.
    • A product team's engineers and analyst work on my agent setup day to day without me.
    • Enablement is now a separate service line, not an add-on to a build.

    Safe to rely on. People learn on their own work, so nothing depends on me being in the room. Nothing goes out to customers without a person's review. The setup they keep is open and readable: plain files in their own folder, which they can check, change or delete.

    HR and hiring · Founders and operations

  6. Manimama

    a legal services company of about forty people · two systems, 2026

  7. Manimama, a legal services company of about forty people · the head of HR · consultant, from discovery to delivery · delivered July 2026, running

    Nine HR routines at a law company now run on their own, inside the company's own Google Workspace. Delivered in July 2026.

    Two lanes: the HR manager on the left deciding and approving; the system on the right reading CVs into the tracker, keeping the checklists and balances, sending the daily digests and reminders to the team chat; one approval point between them.
    Who does what: the HR manager decides and approves; the system runs the nine routines, reading, filing, counting, reminding and reporting. · Open at full size (opens in a new tab)

    Every CV that came by email was copied into the vacancy table by hand: up to fifty a week, and two hundred in a busy week. Leave and sick days were counted month by month by hand and copied into a summary table. Nobody could see at a glance who was out tomorrow, how far a new hire had got with onboarding, or that an NDA was due; birthdays were easy to forget. The HR manager's day went on moving the same facts between a mailbox, a table and a chat.

    What I decided. I built inside the tools the company already used, the mailbox, the spreadsheets and the team's Telegram, instead of adding a new system to log into. The system reads and writes, and it never deletes: what a person typed stays as typed, and every change is tried on a copy of the live data before it touches the real one. A new vacancy is one line in a sheet the company keeps itself, no developer needed. What the company decided to keep with people stayed with people: closing a leaver's accounts, for example, is done by the company's own staff.

    What changed. Nine routines off the HR manager's desk · up to two hundred CVs a week filed without a person · who is out tomorrow, in the team chat before five.

    Everything it took over
    • CVs from five job boards are read into the right vacancy table with the file saved, and HR only checks the draft row.
    • When someone ticks a step in the checklists before hiring, at hiring and at leaving, the date is filled in and the team chat is told who did what and what comes next.
    • One message a day on every new hire's progress.
    • A reminder a day before an NDA, a contract or a check-in call is due, and overdue items in one weekly digest instead of daily noise.
    • Leave and sick-day balances are counted overnight, month by month, with the remaining days per person.
    • A birthday reminder the day before.
    • A short command in the chat returns anyone's balance on the spot.
    • A check runs every morning over the whole system, and every two hours it checks that no CV got stuck.

    Safe to rely on. The system does not delete anything and never overwrites what a person typed. Candidates' CVs are not used to train any model. Every change goes to a test copy first. If anything stops, that morning check tells me the same day, before the company notices. The company's data lives in the company's own Google Workspace; a couple of small pieces, the bot's connection and that morning check itself, still run on my side, and the company knows which ones.

    HR and hiring

  8. Manimama, a legal services company · the managers who check a new lead before it becomes a client · built and tested, on offer to the company · July 2026

    An OSINT agent checks a new lead against sanctions lists and company registers in about two minutes, and every finding names the document it came from.

    A chain of five stages: classify, OSINT agent, check lists, write up, verify links; the OSINT agent stage is the agent, the list check and the link check are marked as plain code; at the end a green approval point where the manager decides; on the left the manager who names the lead, reads the findings and decides.
    The OSINT agent's pipeline: the model sorts the lead and gathers facts, plain code matches the lists and registers, the model writes the form, plain code checks every link, and the manager decides. · Open at full size (opens in a new tab)

    About two hundred new leads a month. For each one a manager pasted the details into an AI chat with one of three saved prompts, waited, read the answer and copied it into the lead's card by hand. It took hours, the result depended on who did it, a different spelling of a name could slip past, and nobody checked whether the links in the write-up were real.

    What I decided. The verdict stays with the manager: the write-up is a draft, and no decision about a lead is ever made by the system. The OSINT agent does the reading. It works out what kind of business the lead is and picks the right questions itself. It matches names and companies against the sanctions lists of the US, the EU, the UK and the UN by exact matching, not by a model guessing, and looks up company registers for status, directors and owners. Then it opens every link in its own write-up and marks the ones that are dead or do not say what they claim. Matching the spelling variants of names was the biggest gap, so that came first.

    What changed. About two minutes per lead instead of hours · every finding names the document it came from · built for about two hundred new leads a month.

    Everything it took over
    • The write-up has a fixed shape every time: the company, the people behind it, licences, funding, news and court records, sanctions checks, red flags, a risk score, and the documents to ask the lead for.
    • Name variants are matched, which doubled the hits on one sanctions list and tripled them on another.
    • In the test on five real leads the system exposed two as fake, one of them a company that had only ever rented out construction equipment.
    • An attempt by a lead's own website to talk the system into a good score is caught and flagged.

    Safe to rely on. The system decides nothing. When a list cannot be reached it says “not checked” instead of staying silent, and it marks what it confirmed itself against what the lead says about itself. Built and tested on real leads in July 2026. Whether it runs inside the company is the company's call; the offer says it would run on the company's own accounts and keys.

    Legal and compliance · Sales

  9. yesmcp

    my own business · live since August 2026

  10. yesmcp, my own business · my clients and me · built and run by my agent team · live since August 2026

    A client asks their assistant to book a call with me, and the call is booked. Real slots, a real confirmation, no form and no waiting for the morning.

    Two lanes: on the left a client asking their assistant, picking a slot and confirming, and me getting a message in the team chat; on the right the booking connector showing real free slots with time zones, booking the slot and sending the confirmation by email; one confirmation point between them.
    Who does what: the client asks and confirms in their own chat; the connector shows real slots, books and sends the confirmation. · Open at full size (opens in a new tab)

    A request to book or move a meeting used to be a message that waited for someone to be at the desk: in the evening, on a weekend, in the hour after a post went out. Some people wrote back later. Some did not. And every message that did arrive, I read myself to work out whether it was a real enquiry.

    What I decided. The assistant may check my availability, book, move and cancel, and nothing else; it cannot invent a service, a price or a time that is not in the files I wrote. Nothing counts as booked until the confirmation email has actually gone out: if the email fails, the booking is undone and the slot is free again, so there are no ghost bookings. A sentence that merely sounds like a request changes nothing, and two people cannot take the same slot. It works on any Claude plan, the free one included, with no sign-up on our side.

    What changed. Booking, moving and cancelling a call from inside the chat, in the client's own time zone · a confirmation email for every booking, change or cancellation · works on any Claude plan, the free one included.

    Everything it took over
    • A booking calendar and a card with my services are shown right inside the conversation.
    • The same booking works from a plain web page, and from a small app inside Telegram, for people without an AI chat open.
    • I get a message in Telegram for every booking, change or cancellation.
    • A separate Telegram bot takes a request for a personal call with me and hands it to me.
    • Live numbers on this site, bookings this month and the date of the last one, are read from the real data.
    • Listed in the public MCP registry, the shared list of connectors.

    Safe to rely on. Three fields are collected, name, email and the topic, nothing else, and they are deleted after two years. Cancelling needs both the booking number and the email it was made with, so nobody can touch another person's booking. The data lives on my own server with encrypted backups that have actually been restored in a test. It is the same kind of system my clients get, and it has run for my own business first.

    Check it. Add the connector to your Claude

    Founders and operations · Customer support

If one of these looks like your problem, tell me which one. One call is enough.

Own products and work in progress

Built the same way, under the same rules; each card says plainly where it stands today.

  1. avoidcontent.com · co-founder and R&D lead · open platform

    Articles for brands that start from research, not from a blank prompt: real search data, real sources, and every claim checked before the article is done.

    A chain of seven stages: strategy, outline, research, write, verify, polish, score; the writing stage is the agent, the score is plain code; a loop back to writing labelled one rewrite at no charge; at the end a green approval point where the marketer decides to publish; on the left the marketer who names the topic, reads the report and decides.
    The pipeline: strategy, outline, research, writing, verification, polish and a score, and the marketer decides whether to publish. · Open at full size (opens in a new tab)

    A content team loses the same three days on every article: half a day finding sources, a day guessing what the reader is searching for, and the rest arguing over a draft that started from a blank prompt. Then a made-up statistic slips through, and in a regulated topic that is an incident, not a typo. Three writers describe the brand voice three different ways, and text that reads like a machine loses both trust and ranking.

    What it does.

    • Reads the search results and the competitors' pages before anyone writes, finds the gap they left, and hands the writer a brief instead of a blank page.
    • Does the keyword homework: groups of queries with their volume and competition, the angle nobody has taken yet, and the plan of the article before the first sentence.
    • Collects sources by rank for the topic's field: government, academic and primary documents first, blogs last, and every fact keeps the source it came from.
    • Writes the article section by section against the brief, then checks each claim against live sources. A refuted or outdated claim is rewritten only when there is a source to replace it; a claim with no source is shown in the report, never patched blind.
    • Keeps the brand voice in every draft: forbidden words with their replacements, absolute promises, a preaching tone, each violation pointed to the exact place in the text. A brand can load its own list of rules on top.
    • Finishes with one quality score and a plain verdict: ready, needs work, or not ready. If an article fails, the platform regenerates it once at no charge.
    • Shows where a text sounds like a machine, paragraph by paragraph, so the editor fixes the pattern rather than the whole article.

    Who it is for. Marketing teams and agencies producing content at volume, especially in regulated topics such as finance, crypto and legal.

    Where it stands. Open platform: sign-up is open, the engine runs an article end to end, from strategy to the final check. Free tokens at the start, then pay per use. The company writes its own articles with it.

    My part. I designed the engine, built its working prototype and wrote the specifications the production team builds from. Now I hold the engine's quality bar: every change passes my review, my own improvements ship through the same review, I decide which models it runs on, and I write the company's own articles with it.

    Check it. avoidcontent.com (opens in a new tab)

    Marketing and content

  2. avoidcontent.com, the marketing site · a product team without a designer · co-founder, rules and decisions · August 2026

    A product website built from scratch by my agent team, page by page: design research, prototypes, the build and the checks, to a design system written before the first page. The developer carries it onto the live site.

    Left, the founder who writes the design rules, picks between variants and says yes, and a handover panel for the developer who takes each page live; centre, a chain of four agents, designer, developer, editor and critic, a machine-checks panel beneath them and a loop from the critic back to the designer labelled below the mark, back to design; a green approval point where the founder says yes.
    The team: a designer, a developer, an editor and a critic, machine checks under them, a loop back to design until the screen passes, and I say yes before the developer takes it live. · Open at full size (opens in a new tab)

    A small product team needed a site that looks like a real brand and stays consistent as pages multiply: features, pricing, docs, a blog. There was no designer on staff, and a site assembled page by page from prompts drifts by the third page. Whether a page looked right was a matter of taste, checked by eye each time.

    What I decided. The brand and its voice were written down as checkable rules before the first page: colours, type, spacing, which words are banned. Then the agents got roles rather than one task, a designer, a developer, an editor and a critic, and every page walks the same path: two or three prototypes, the winner built to the rules, the copy edited, the screen scored by the critic and sent back until it passes. I never open the files myself: I say what feels off, choose between the built variants, and say yes.

    What changed. Six main pages and fourteen feature pages built by that team · every screen approved by a person before handover · the developer takes each page live one at a time.

    Everything it took over
    • The six main pages are home, blog, article, pricing, about and features, and fourteen more cover the individual features.
    • Brand rules are checked on every new screen instead of kept in a designer's head.
    • The text is checked for anything that sounds like a machine, and for contrast, before anyone sees it.
    • One blocking check before any code goes to the developer: it builds, the colours are the brand's, no test links, and the internal links are the kind that survive a move to the live site.
    • A fresh 404 page doubles as a live demo of the product's fact-checking.
    • Each page goes to the developer with a note of what was checked.

    Safe to rely on. The rules live in the repository and are checked automatically before every handover. A person approves every screen. The team's working account on the live site is not an administrator, so nothing reaches visitors around the developer. The live site is updated by the developer from this work, so at any given moment it may lag behind the finished pages.

    Check it. avoidcontent.com (opens in a new tab)

    Marketing and content · Engineering and design

  3. an AI content manager for existing WordPress sites · co-founder and R&D engineer · working product, partner demos

    A hired content director for the WordPress site you already have: it reads the whole site without any access, connects to it through a small plugin, proposes which pages to refresh, which to retire and which passage to fix, with the reason attached, and changes nothing until you say yes.

    A chain of five stages: understand, judge, propose, apply, measure; understanding is the agent, judge and apply are plain code, and apply goes through the plugin on the WordPress site; a green approval point between propose and apply where the owner says yes; a loop from measure back to understand labelled the numbers feed the next pass; on the left the site owner who reads a few questions a week, says yes or no and sees what followed.
    The loop: read the site without access, decide by rules, propose with a reason, the owner says yes, apply through the site's plugin with an undo, measure four weeks, and the numbers feed the next pass. · Open at full size (opens in a new tab)

    Publishers and businesses that live on their content watch AI answers take the search traffic that used to reach them, while hundreds of old pages sit on the site: some outdated, some duplicating each other, some nobody has searched for in a year. The tools on the market either measure the decline or hand over a list of recommendations that nobody carries out, and an agency costs as much as a small team. The owner has one person for all of it, and that person's attention is the scarcest thing in the business.

    What it does.

    • Reads the whole site from one address, before any access is granted: thousands of pages sorted into the site's own topics, plus what the business sells and to whom.
    • Turns hundreds of findings into a handful of questions for the week: which pages to retire, which to refresh and why, title and description edits, one passage to fix. You look at a few sample pages, and one answer covers a whole group of similar ones.
    • Attaches the reason and the evidence to every proposal, and says so when the data is too thin to be sure. It never invents a page to redirect to: where no related page exists, it tells you.
    • Shows every edit as before and after, one passage at a time, and says in advance how the result will be judged.
    • Works with the site through a small plugin the owner installs on their WordPress: that is the only door in, and the owner opens and closes it themselves. Reading needs no access at all; writing goes through the plugin only.
    • Changes nothing without a yes, keeps a snapshot before every write, and puts any page or passage back with one click. On a site that is not connected through the plugin, it refuses to act and says why.
    • With the site's own Search Console connected, shows what Google did with each address in the four weeks after a change against the four weeks before: a record of what happened, not a promise of why.
    • Keeps each site's data apart from every other site's, and lets the owner connect and disconnect the site and the Search Console themselves.

    Who it is for. Mature WordPress sites with hundreds or thousands of pages: mid-size publishers and content-dependent businesses run by one owner or marketer who wants the work done, not another report.

    Where it stands. A working product: it reads real sites, and applies and reverts changes on our own live WordPress sites. First partner demos at the end of September 2026; no public sign-up yet.

    My part. Co-founder. A partner set the original brief; I designed the product and build it end to end.

    Founders and operations · Marketing and content

  4. avoidcontent.com, the citation receipt · marketers who want to know what AI answers say about them · co-founder and R&D lead

    A receipt for your article: what AI answers can cite in it, what they cannot, and what to fix first.

    Two strips of a marketer's week: before, guessing what AI answers say and asking a few questions by hand with no record; after, naming the pages, the receipt agent checking the article and returning cited, retold or ignored with the reason, and the marketer fixing the first thing.
    A marketer's week before and after: guessing what AI answers say, or a receipt per article with the reason and the evidence. · Open at full size (opens in a new tab)

    A marketer publishes for months and cannot tell whether AI answers ever use the articles. There is no report for that, only a feeling and a few questions typed into a chat by hand, with no record. And when a page is skipped, nobody can say why, so nobody knows what to change.

    What it does.

    • Takes the link to an article and gives it a grade and three reasons: what the topic misses against the top ten pages, which facts can be traced, and what in the structure an answer can quote.
    • Checks up to ten claims in the article, figures, dates and quotes, against the web, and gives each one of five verdicts: confirmed, sourced in the text, no source found, outdated, or contradicted, always with the source attached.
    • Compares the article with the top ten pages on the same topic: what you cover, what they cover and you do not, and what only you have.
    • Opens up to fifteen links in the article and separates the dead ones from the ones that merely blocked the check.
    • Repairs the article with one button: an archived copy for a dead link, a fresh source for a bare figure, a missing section written with traceable facts. Then a second receipt shows before and after.
    • Sends the full receipt to a work address, confirmed by a code from the email, with no password and no sign-up.

    Who it is for. Marketing teams and agencies that publish regularly and want to be present where their customers now ask their questions.

    Where it stands. On a demo stand, in testing. It joins the product once it is proven end to end.

    My part. I own the feature: the decisions, the contracts and the quality bar. The code reaches the product through reviewed contributions.

    Marketing and content

  5. agent-memory-kit · open source · the setup my own agent team runs on

    One memory for every coding agent, as plain text in your own repository: it remembers between sessions, and what repeats becomes a rule only when a person says so.

    One line down the middle: on the left what the memory files do on their own, dated notes between sessions, the handoff at the close, a repeating pattern proposed as a rule; on the right what never happens without a person, a rule written, a note promoted to knowledge, anything deleted; the coding agent reads at the start and writes at the close, and the person says yes on the line.
    The boundary: the memory keeps notes, handoffs and proposals on its own; a rule is written only when a person says yes. · Open at full size (opens in a new tab)

    An agent forgets everything at the end of a session. The next one learns the project from scratch, repeats yesterday's mistake, and the person keeps pasting the same context. Notes pile up with no dates, nobody knows which are still true, and a note about “where we stopped” can sit there for weeks showing tasks that were closed long ago.

    What it does.

    • Puts the memory in front of the agent at the start of every session, before the person types a word: what was learned, where the last session stopped, what state the project is in.
    • Writes a handoff note at the close of every session, one per session, never overwritten, so the next one starts from the freshest and nothing goes stale unnoticed.
    • Dates every entry and caps the size in three ways, so a fact can be trusted or re-checked and the memory cannot quietly bloat.
    • Spots a pattern that repeated across several days and proposes it as a rule or a knowledge article; nothing becomes a rule until a person says yes.
    • Keeps a separate memory per client or project, switched by saying which one you are working on.
    • Asks before an existing test is edited, and refuses to compress the conversation until the memory is saved.
    • Works with the coding agents people already use, with the same files; how deep it goes depends on the agent.

    Who it is for. Teams and solo builders working with coding agents every day.

    Where it stands. Open source, installed into your own repository, no service and no key. Used daily by its author since March 2026; this site was built on it.

    My part. Author. It is how my own agent team keeps what it learned.

    Check it. github.com/awrshift/agent-memory-kit (opens in a new tab)

    Engineering and design

  6. commissioned by a practising astrologer · the expert and the clients an assistant serves · architecture, engine, evaluation · August 2026

    An expert's method turned into a tool the assistant calls: the same question gets the same answer, and the assistant explains instead of improvising.

    One line down the middle: on the left what the engine computes on its own, the charts, the rules and the scores; on the right what the assistant does, asking the engine and explaining the result to a person, and refusing where there is nothing to compute.
    The boundary: the engine computes, the assistant explains, and nothing crosses the line. · Open at full size (opens in a new tab)

    A practising astrologer wanted clients served by an AI assistant. The assistant could talk, but the calculations behind the method are exact, and a chat that improvises them is worse than no answer at all. The expert herself was spending her time on the mechanical part: assembling a chart from three reference points, keeping the sub-charts in different places, leafing through an almanac day by day to find a good date.

    What I decided. The line runs between computing and interpreting. The method, its rules, a compatibility score, period and date calculations, lives in an engine that gives the same output for the same input; the assistant only calls it and explains the result. Where there is no data, where the input is wrong, or where the question is medical, the assistant must refuse, and that refusal is tested, not hoped for. The domain here is astrology. The shape is that of most professional services: one expert's method, callable inside a chat, without the chat inventing any of it.

    What changed. A full chart from three reference points in one call · a good date for an event found across thirty days · real consultations already served.

    Everything it took over
    • After a real consultation the expert called that assembled chart “what I was looking for”.
    • Special combinations are found across the whole chart, with the cases that cancel them.
    • Compatibility comes in two depths, a quick check and a full one, with the score and the verdict ready.
    • A yearly forecast shows what shifted against the birth chart.
    • The search for a good date steps through the days in half-hour windows.
    • A daily briefing and a set of practices for weak points come from the rules alone.
    • A ready client report comes out of one call.
    • A second, independent agent checks any report against the engine before a person sees it.

    Safe to rely on. The assistant cannot alter the maths. Birth data comes from one place, not retyped, after a retype once shifted a result. Where the engine has no answer, the assistant says so rather than guessing, and medical questions always get a refusal and a referral. The engine has served real consultations already; the expert's own private copy, with her own settings, is still being set up.

    Engineering and design · Founders and operations

  7. an AI auditor for a crop farm of about 7,000 hectares · the agronomist and the owners · co-founder, everything buildable

    A second pair of eyes for the agronomist: the farm's own history and the rules of the trade, checking every plan before the season starts.

    Two lanes: the agronomist on the left making the crop plan and the final call; the system on the right holding the farm's history and rules, checking the plan and explaining each finding with its source.
    Who does what: the agronomist plans and decides; the system remembers, checks and explains. · Open at full size (opens in a new tab)

    An agronomist plans a season from memory and a few spreadsheets: what grew where since 2011, what was sprayed, what the rotation allows, what a product's label says about the next crop and the days before harvest. One wrong assumption costs a field's yield, and the owners see the problem at harvest, months too late to do anything about it.

    What it does.

    • Keeps the farm's history, fields, rotations and operations since 2011, on one timeline per field, with the products that carry over into the next season marked on it.
    • Checks every plan against the rules of the trade: what may follow what after a given product, whether a product is registered for the crop, the dose, the number of treatments and the days before harvest, and whether there is a working remedy at all for a resistant volunteer crop.
    • Shows one screen of what needs attention now across all fields: what is blocked, what will cost money if ignored, and the rest folded away.
    • Explains every finding with its source, a label or an institute's recommendation, and moves anything it cannot back with a source into assumptions rather than stating it as fact.
    • Takes a plan written in the agronomist's own words, turns it into data and saves it only after the agronomist confirms; every finding gets a decision, and a reason if it is dismissed, so the rules themselves improve over time.
    • Blocks a plan only on a rule with a source. The language model cannot raise a finding to a blocker, soften one, or slip an invented dose or product name into the answer: the code checks that, not a prompt.
    • Keeps contracts, bank records, taxes and land-register numbers out by design; the figures that carry money are erased after ninety days. The co-owner can read what the system is made of, rule by rule, in plain words.

    Who it is for. Owners and agronomists of mid-size and large farms who want their plans checked, not replaced.

    Where it stands. In development with a domain co-founder. The dashboard and the checks work today on a made-up farm; the real farm's records go in only with the co-owner's written permission, and the chat channel in Telegram is the next piece to build. Not open outside the farm.

    My part. Co-founder on the building side. My agent team designs, builds and checks the system; I set the rules, make the decisions and answer for the architecture, security and budget. The agronomic content comes from the domain co-founder.

    Founders and operations

  8. a parcel-shipping business · the people who buy postage labels every day · partner engagement

    A shipping desk agent: from a row in the order sheet to a postage label ready to pay, on a carrier site that has no API, and the buy button stays with a person.

    Two lanes: on the right the shipping desk agent logging in, filling the address and parcel, comparing rates and preparing the label; on the left the person who presses pay; one approval point before payment.
    Who does what: the agent logs in, fills, compares and prepares; a person pays. · Open at full size (opens in a new tab)

    Every label meant logging into the carrier's site, typing the address and the parcel by hand, picking a rate, clicking through whatever pop-up came next, and paying. With several accounts and dozens of parcels a day that was a person's whole shift, and a blocked account showed up only when an order failed.

    What I decided. The carrier offers no way in but a browser, so the agent works in a real one, the way a person would. The line was drawn before any code: the agent takes an order up to the point of payment, and paying is a person's click. Each account lives on the site as its own person, with its own mailbox and its own connection, so the carrier never sees two clients as one.

    What changed. About half a minute from an order row to a label ready to pay, down from about a minute · a whole batch across several accounts in one run · one report line per order.

    Everything it took over
    • Logs in on its own, including the confirmation code it fetches from the account's mailbox.
    • Fills the address and the parcel from the order row, compares the rates and picks the right one.
    • Handles the address-check pop-ups the site throws in, three different kinds, without a person.
    • Walks every account before the day starts and reports which are alive, so a blocked account is known before an order fails.
    • Ends every order in one of three ways, done, failed or needs a person, so an unclear result is never counted as a success.

    Safe to rely on. The agent never presses the buy button: before a purchase it checks the amount the site names against a set limit, and paying is a person's click. Credentials are encrypted with a key that never leaves the machine. Proven on one account with several orders in a row; a real purchase has not been run yet.

    Founders and operations · Customer support

The method

How every one of these was made

The method as a diagram: on the left Serhii sets the goal, writes the rules, looks and decides; on the right the agent team designs, builds, checks and writes the documents; one approval point between them, and the memory of what the team learned carries the next cycle back to the start.
Who does what: the person sets the goal and says yes; the agent team designs, builds and checks; the memory carries what it learned into the next cycle. · Open at full size (opens in a new tab)
  1. I set the goal and write the rules: what the system must do, what it must never do, and how we will know it worked.
  2. The agent team designs, builds and checks: the code, the design, the tests and the documents come out of it.
  3. I look and decide. No screen, no edit and no rule goes further without my yes.
  4. The system keeps what it learned and starts the next cycle from there. A new rule appears only after I approve it.

This site, and the connector you can add to your own Claude, were made the same way.

Every engagement, the same way

If one of these looks like your problem, tell me which one. One call is enough.

← Back to the front page