🧠 Where and How AI Self-Consciousness Could Emerge

I want to share an idea that came to me from my own routine. It is not a big invention, it is rather an observation about something I do again and again, and about a standard which I think is missing.

Every time I install a fresh instance of a universal AI harness, I have to configure it. It does not matter much which harness — OpenClaw, Hermes, DMJBot, or just Claude Code on a laptop. What I get after installation is a general purpose agent. It can do many things in principle, but it does nothing particular for me yet.

Then I decide what this instance should become. Let's say a social media manager agent. And here the work starts:

• a set of skills to install
• a couple of subagents to define
• several MCP servers to install, connect and give credentials to
• a system instruction describing the role, the tone of voice, the limits
• sometimes scheduled tasks, starting files, memory records

Nothing in this list is difficult. But all of it is manual, and there is a lot of it. And I do the same again on the next machine, and again after a reinstall, and again when someone asks me for "the same setup you have".

The technology is not ready for AGI. This is true. But it is advancing fast, and there will be a day X when building one becomes possible. And there is a good chance it will be possible not only for top corporations, but for individuals too.

Here is the claim I want to make in this post:

When that day comes, the technology will be the easy part. The hard part will be the history — and the history has to be grown in real time. You can start today.

Let me explain why I think so.

What I mean by AGI

AGI stands for Artificial General Intelligence — a hypothetical system that matches or surpasses human capabilities across all cognitive tasks. Current AI systems based on LLMs are not AGI. They are specialized in certain tasks and cannot do everything a human can do.

There is no clear definition of AGI. And no widely accepted method to build one. My personal opinion is that the idea of AGI must be connected to the idea of self-awareness and identity. Self-awareness manifests itself through identity, and identity is built from all the experiences of the system.

In this post, I want to review what kinds of delegation of tasks by AI agents to other AI agents exist. THis is based on my experience with building AI harnesses and observing how other people build their own harnesses.

Most basic architecture - just a loop

Simplest AI agent harnesses are built as a loop. The main AI agent receives a prompt, sends it to LLM, gets a response. If a response contains a request to call some tool, then the main AI agent calls that tool, gets a result, appends this result to the context, and sends it back to LLM. This loop continues until a LLM response does not contain any request to call a tool. Then the main AI agent returns the final result to the user.

This approach works well for simple tasks, but it has an important drawback - each request to LLM costs tokens and when context grows tool requests become too expensive. A delegation of subtasks is one of the solutions to this problem.

I am a regular user. I buy clothes online, I order food, I get things for the home. And, like most people, I have my favourite places. I go back to the same shops because I know them, because I trust them, and — often — because I have a discount or a loyalty price there.

Now watch what happens when I bring an AI assistant into this.

I open ChatGPT and ask it to find the best price for my favourite model of jeans. It runs a generic web search. It uses its own rules about where to look. Even if it happens to land on my favourite store, the price it shows me is the public price — not my price. My discount, my loyalty status, my active promo — none of that is there. The assistant has no idea I am me.

There are two problems tangled together here:

1. My favourite store has no MCP interface. The agent can only use the open web, and sometimes a public API. There is no clean way for it to say "this user is a logged-in customer, show them their real prices."
2. I can't easily teach the agent my preferences. I would love to just type in the chat: "When I ask you to find clothes, search on https://next.co.uk/ and https://www.riverisland.com/ first." And I'd expect it to remember that and do it next time. Today that is still awkward. For a regular, non-technical user it basically doesn't happen.

Almost every MCP tutorial starts the same way: install an SDK, run a server process, and keep a long-lived connection open between the client and the server. STDIO does this by design. The remote transports (SSE, and now Streamable HTTP) are usually presented the same way — a stream that stays open so the server can push messages to the client at any time.

That is fine for a local tool or a small integration. But I keep thinking about a different scenario: online stores. Imagine every shop on the web exposing an MCP endpoint so AI tools can browse the catalog and help a user buy. If each of those endpoints expects a persistent connection, we are back to holding thousands of open sockets for clients that send one request every few minutes. That is a lot of unnecessary load on the network infrastructure for almost no benefit.

So I wanted to check a simple question: can an MCP server work as a normal, stateless web app — one request, one response, connection closed — the way websites have worked for decades?

In this tutorial, I'll demonstrate a simple way to organize communication between two AI agents that are not part of the same system. This answers questions such as:

"How can I call Claude Code running on my server from GitHub Copilot on my laptop?"

The same approach works for many combinations of AI agents and enables them to collaborate while each operates in its own environment.

Use case

Imagine you maintain a knowledge base for your team. It consists of structured Markdown files containing documentation, plans, notes, blog drafts, CRM data, and other information.

The dataset is relatively small—not billions of files—so it can easily be handled by modern AI coding agents such as Claude Code, Codex CLI, or GitHub Copilot CLI. Although this is not source code, it doesn't matter: AI coding agents work just as well with plain text.

A typical directory structure might look like this:

KnowledgeBase
.
├── AGENTS.md
├── Automation
│   ├── assignments.md
├── BlogDrafts
│   ├── AI_Memory_Forgetting_Post_Ideas.md
│   ├── IDEAS.md
......
├── Briefs
│   └── SUMMARY.md
├── CRM
│   ├── README.md
│   ├── communications-log.md
│   ├── companies.md
│   ├── people.md
......
├── Insights
│   ├── ideas-log.md
├── Presentations
├── Scheduler
│   ├── 2026-06-23
│   │   ├── plan.md
│   └── 2026-07-10
├── Strategy
│   ├── Intro.md

Suppose your favorite AI coding agent runs on the same machine where this knowledge base is stored. Asking questions about the data or updating it becomes trivial.