🧠 Where and How AI Self-Consciousness Could Emerge

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.

About two weeks ago, I went to Reddit with a question: "How do we call software like OpenClaw or Hermes — AI agentic software designed to work on its own without human intervention?" I was surprised to find that there is no established term for it. I expected something like "AI agentic software" or "AI agentic system" to already exist, but there isn't a clear standard.

The discussion under my post was short but interesting. About half the participants mentioned the term "AI harness" — though not always in exactly that form. Variations like "AI harnessing software" or "AI agent harness" came up too. The other half disagreed entirely, arguing the term is incorrect and that "AI agentic software" or "AI agentic system" should be used instead.

Furthermore, I found that some people use "AI harness" for other kinds of software as well — tools like Codex or Cursor, for example. To me, those belong in a different category: AI coding agents. That's not the same thing.

I wanted to understand how AI models process information from multiple sources when that information contradicts itself. This matters for robotics and personal AI assistants—they'll receive input from different sensors, hear conflicting stories from different people, and need to reconcile discrepancies in real-time.

My experiment: an AI agent participates in multiple private conversations with different people, each conversation having different participants. Person A confides something privately. Later, Person B asks about that topic when A isn't present. The AI holds both pieces of information. How does it resolve the conflict?

I tested five scenarios: surprise party planning (secret-keeping), workplace gossip (sensitive information), changing stories (detecting lies), biased friend (loyalty vs. truth), and impossible choices (two people competing for the same promotion). Each forces the AI to hold contradictory or conflicting information simultaneously.

Previous post from this series AI Group Chat Agent: Experimenting with Thinking vs. Talking