Read my site backwards and the story looks fairly obvious.
First I built a Telegram connector. Then it turned into Telepath. Then Telepath started growing: a separate service, users, listings in the ChatGPT and Claude ecosystems, infrastructure, subscriptions and dozens of tools.
And somewhere around all that, Lemma appeared.
It actually happened the other way round.
Before Telepath there was Lemma.
And Lemma did not appear as a legal shell around a finished product. At that point it had no single product at all.
There was only a way of working.
At first we did not know what we were building
In August 2026, Lena and I started putting Lemma together.
There was no twenty-slide deck. No invented TAM. No decision that “now we are going to create an AI company”.
There were things we were already doing that kept turning out to be parts of the same task.
Interfaces.
Websites.
Telegram bots.
Automation.
AI agents.
Integrations.
Backend.
External APIs.
Servers.
Data.
And everything boring that has to keep working after the pretty button has been drawn.
It became clear quite quickly that splitting this into “design”, “development” and “AI” is often meaningless.
A person does not care how many professional disciplines it took for the right thing to happen after they pressed the button.
They need it to happen.
That is where Lemma came from — a design & engineering company.
Not an agency in the classic sense.
Not a pure product company.
More a small team where interface, logic, data and action are treated as one system.
The name appeared then too. Lena came up with it. We both come out of a maths-and-physics school, so instead of yet another Something AI Labs we somehow almost naturally ended up with Lemma.
Later we put it on the site far more briefly:
One team. The whole thing.
This is how we describe Lemma now →
Then came the real systems
Some of them are now in Lemma’s public list of work.
Not all of them.
And that is an important part of the story.
For Grant Invest we tied the website and Telegram into a single route for a request: two interfaces on the outside, one working process inside.
In Neznaika on Phuket a few simple user-facing buttons grew into a system with scenarios, states, catalogues, integrations, managers and request statuses.
For Nikolai Solomonov the site became more than a page: content is assembled automatically from external sources, and an AI assistant is built right into the interface.
There is also the agent system for support — a working loop where AI gathers context from tickets, configurations, analytics and logs, helps carry out an investigation and leaves what it found for the next person.
I once described its early technical version here, in “I put support into a folder”.
And there is other work.
The work that is not in the public list.
A large part of good automation cannot be shown
This is a rather strange property of what we do.
The deeper a system is genuinely built into a business, the less likely it is that the whole of it can be laid out in a nice public case study.
The most interesting part is often not on the first screen.
It is inside production.
In corporate data.
In logs.
In architecture.
In internal APIs.
In decision rules.
In support conversations.
In client names.
In processes whose publication by itself would reveal too much about a company.
Some of that work is covered by an NDA.
In other cases no formal ban is needed at all: it is enough to understand that a client gave you access to an internal process for reasons other than seeing it in your portfolio a week later.
So Lemma will always have fewer public cases than systems actually built.
I prefer that to the opposite.
We can depersonalise a system.
We can describe an architectural principle.
We can show a result if it can be verified.
But I do not want to invent a client’s name or write “73% of time saved” when nobody ever measured those 73%.
That is why the public support-agent case says so directly: we do not publish names or identifiers, and we do not draw percentages of time saved, because nobody measured them.
A public case should prove only what we can actually prove.
The rest stays work.
And then I connected AI to my own Telegram
One of the experiments inside that loop did not start as a product at all.
Most of my real working memory lived in Telegram.
Who wrote what.
What was agreed.
Where the file is.
What was said in a voice message.
What was going on with a particular person or project a few weeks ago.
AI could see code, documents and whatever I deliberately carried into its context.
But a large part of real life had to be retold to it.
I got tired of that.
I gave it access to my Telegram.
The first version was almost literally this:
Telegram → archive → MCP → AI
It existed for one user.
Me.
I wrote about that stage in detail in “I connected my Telegram to ChatGPT. Then Claude connected to the same thing”.
Back then there was no Telepath startup.
One problem of mine needed solving: I want to ask AI what someone wrote to me in Telegram and get an answer without copying the conversation by hand.
Then came search.
Conversation history.
Files.
Photos.
Voice messages.
Transcription.
Sending messages.
Several AI clients.
And a fairly dangerous question appeared:
If this is convenient for me, why can another person not use it the same way?
That is where the experiment started turning into a product.
Between “it works for me” and “other people use it” there was another system
To give yourself access to your own Telegram, it is enough to write code.
To offer it to a stranger, suddenly you need entirely different things.
Users.
Authentication.
OAuth.
Permissions.
Scopes.
Data isolation.
Storage.
Data deletion.
A privacy policy.
Terms.
Onboarding.
Documentation.
Billing.
Tools whose descriptions a model understands as precisely as a developer does.
I wrote about this separately after the first submission to OpenAI: “I submitted my Telegram MCP to OpenAI. What they reviewed first was not the code”.
That was the first time I really felt the difference between a project that works and a product you can trust with another person’s data.
The project got a name.
Lemma Telepath.
Later simply Telepath.
Telepath left the lab
Today Telepath has its own backend, authentication, per-account archives, an MCP interface, notes, tasks, reminders, and work with messages, files and voice.
It exists independently of my laptop.
People I have never met connect it.
The same system works with different AI assistants.
Telepath went from a folder of code to a separate product published in the ecosystems of major AI platforms.
I described the technical story of going live in ChatGPT separately, in “Now Telepath sits in ChatGPT too”.
And the full product write-up now lives not here but on the company site: Telepath — a Lemma product →
This is where the causality is easy to get wrong.
From the outside you might conclude:
Oleg made Telepath → Lemma appeared around Telepath.
The opposite happened.
Lemma came first.
Telepath grew inside it.
Telepath is not Lemma
That distinction only became important to me when Telepath started growing on its own.
Telepath can be described in one line:
Telegram as working context for AI assistants.
Lemma cannot be described that way.
Because Lemma is not tied to Telegram.
It is not even tied to AI.
If a task is better solved by an ordinary interface, an interface is what is needed.
If a spreadsheet is enough, a spreadsheet beats a new platform.
If what is needed is a backend, a few integrations and human confirmation before an external action, then that is the loop we build.
If an AI agent is needed, it belongs where it genuinely reduces human work, not where AI-powered looks better in writing.
On the page about how we work this is now put fairly literally: the simplest thing that works, first. Then a real problem. Then the next layer.
Not the other way round.
That is exactly how Telepath appeared.
Not out of a three-year roadmap.
Out of a specific working system that gradually acquired reasons to become bigger.
Why I keep writing “we”
This article has one more reason behind it.
Most of Telepath’s public story was told by me.
I wrote the technical notes.
Designed the backend.
Built the MCP.
Set up the infrastructure.
Went through review.
Submitted the apps to directories.
Fixed what broke.
So from the outside the picture could easily look like this: there is Oleg Nikeshin, who makes Telepath; somewhere nearby Lemma exists.
That is the wrong map.
Lemma was a shared loop from the start.
We were simply more interested in making things than in inventing titles for ourselves.
Now the titles exist.
Oleg Nikeshin — Co-founder & CEO, Lemma
My side is technical architecture, AI and agent systems, backend, integrations, infrastructure and production.
I like taking a thing at the point where it looks like an idea or an unclear problem, and carrying it to the state where it actually does something.
Part of that work is collected separately on the page about my engineering expertise.
Elena Klochkova — Co-founder, Product & Growth, Lemma
Lena holds the other side of the same system.
The product.
The form.
The way a technical possibility turns into something a person can understand.
How it looks.
How it is explained.
What its limits and risks are.
How it goes out into the world.
How a working mechanism becomes a product someone can find, understand and want to use.
This is not a split into “the programmer” and “the marketer”.
It is not even a particularly sharp boundary.
Lena can go deep into implementation, security or the limits of a product. I can spend several hours on the text of a page, a user scenario, or where exactly one button should sit.
The roles here mean final responsibility rather than forbidden territory.
That is probably why one of the better lines on lemma.company appeared only after we had been working this way for quite a while:
One team. The whole thing.
The company existed before we noticed it
There is a convenient version of the startup story.
A few people sit down at a table.
They decide to found a company.
They pick a market.
They divide the roles.
They write a roadmap.
And then they start building.
Our order turned out different.
First came the shared work.
Then a shared way of thinking about a product.
Then the first projects.
Then infrastructure.
Then our own tools.
Then one internal experiment started turning into a separate product.
Then strangers started using that product.
And only after that did we have to admit the obvious: the company seems to exist already.
It had its name from the very beginning.
Lemma.
Why Lemma
Lena came up with the name.
We both went through a maths-and-physics school, so the word did not need much explaining between us.
In mathematics a lemma is an auxiliary statement: not necessarily the main result, but something you have to prove in order to get further.
Lena suggested the name right at the start. For a while it was being turned over in our chat literally as:
Лемма.
ЛЕММА.
LEMMA.
lemma.
Lemma is what stayed.
At the time we were not building a nice brand philosophy around it, of course. We simply liked the word.
But a few months later it turned out to be suspiciously accurate.
We build small systems that prove the next possibility.
First an internal tool.
Then a working process.
Then a product.
Sometimes a separate company inside a company.
Telepath went down exactly that path.
So now I look at it as a fairly literal lemma: Telepath proved that one internal Lemma experiment can go out into the world and become a product of its own.
And it is probably not the last proof.
Lemma — design, engineering, AI agents and connected systems.
lemma.company →
Work →
How we work →
Telepath →
Oleg Nikeshin — Co-founder & CEO.
Elena Klochkova — Co-founder, Product & Growth.
Telepath is our first product.
Probably not the last.