Phase 5 - public AI Automation Build Journal
no traditional technical background, learning AI automation by actually building systems with heavy AI assistance.
What Is KAL-7?
KAL-7 is my personal AI orchestration system: a persistent, owner-controlled platform designed to connect artificial intelligence, software tools, information sources and automated processes into a single working environment.
The project began on 21 August 2026 with a simple question.
Instead of opening separate AI applications, issuing isolated prompts and manually carrying information from one service to another, could I build an AI system that remained available on my own hardware, communicated with external services, used tools independently, coordinated specialist AI systems and helped translate everyday intentions into real technical actions?
That question became KAL-7.
At the centre of the system is a Samsung Galaxy S24 Ultra running Android, Termux, Ubuntu and the Hermes agent framework. What started as a relatively compact experiment has since developed into a broader automation architecture encompassing communication channels, cloud platforms, automation gateways, knowledge repositories, collaborative workspaces, monitoring, backups, governance controls and specialist AI workers.
KAL-7 is not simply another chatbot. Nor is KAL-7 a single artificial intelligence model.
KAL-7 is the orchestration layer.
KAL-7 occupies the connective space between me, AI models, applications, services, data and automated workflows. Its purpose is to determine how those components can work together, rather than requiring me to operate each one separately.
An instruction such as “Research this” might involve information retrieval and specialist analysis. “Monitor this” may require an automated trigger, an external service and a notification channel. “Process this information” could involve retrieving material from a knowledge system, transforming it and passing the result elsewhere. “Ask the other systems for their views” may require several AI systems to work independently before their conclusions are brought together.
The intention is that I express the objective while KAL-7 increasingly manages the technical choreography required to accomplish it.
KAL-7 was never intended to become a black box that performs impressive tricks while leaving its owner none the wiser. Building the system is also a method of learning how such systems actually work.
Consequently, KAL-7 has two intertwined purposes.
The first is operational. KAL-7 is intended to become an increasingly capable personal AI system that can coordinate sophisticated automations, knowledge workflows, software services and specialist agents while reducing the amount of manual intervention required from me.
The second is educational. KAL-7 is effectively my working laboratory for learning systems integration, APIs, Linux, webhooks, cloud infrastructure, automation, security, version control, AI agents, reliability engineering and technical architecture.
Every new capability introduces another layer to understand. Every failure exposes an assumption. Every repair becomes part of the education.
As the system has matured, however, another principle has become increasingly important: capability alone is not enough.
KAL-7 should not merely become more powerful. KAL-7 should become more dependable, intelligible and governable.
That philosophy shapes the architecture.
The objective is not unfettered autonomy.
It is controlled autonomy: allowing the system to handle routine work independently while preserving human authority over consequential decisions.
This makes KAL-7 more than a technical project.
KAL-7 is simultaneously the platform I am constructing, the practical assistant the project is intended to produce and the learning environment through which I am developing the skills required to design systems of this kind.
Day 7
Today I pushed the idea beyond one agent doing everything. I began formalising how KAL-7 should use a team of specialist AI resources and how those resources should communicate with me.
The emerging pattern was that KAL-7, operating through Hermes Agent, should stay the owner-facing coordinator while specialist systems handle narrower jobs: coding/development work, recovery, research or later design tasks. This became the foundation of what I would call The Collective.
At the same time, I refined the communication philosophy. Telegram is the fast channel. Email is for things worth a letter. KAL should email when a Collective project finishes or fails, when work requested by email is complete, when something is blocked and needs me, for critical system alerts, or for genuinely important security/deprecation information. Routine health, ordinary subagent updates and low-value noise should stay out of the inbox.
That distinction sounds cosmetic, but it is actually orchestration policy: different channels have different purposes and interruption costs.
What I learned
- Multi-agent systems need clear ownership and role boundaries or they simply create more noise.
- An orchestrator should decide when a specialist is useful rather than blindly delegating every task.
- Communication policy is part of automation design: alerts need severity, audience and a suitable channel.
- Human approval remains important for risky or externally consequential actions.
Reflection
This was the point where KAL-7 began to feel less like a clever assistant and more like a manager of resources. Hermes Agent remained the runtime that made that coordination possible; KAL-7 was the personalised orchestration layer using it. My own role was also becoming clearer: I am the owner and final authority; KAL coordinates; specialist AIs contribute within defined boundaries.
Day 6
Today was valuable because the main outcome was not installing something.
I investigated a rooted-Android/FIDO2/SSH approach that looked technically impressive. The review showed that it was a poor fit for KAL-7. My actual architecture uses Termux and Ubuntu through `proot-distro` on my S24 Ultra, with Hermes Agent providing the runtime through which KAL-7 operates; the alternative depended on rooting Android, entering privileged namespaces and exposing device interfaces to a real chroot.
The decision was to reject that route. Rooting the S24 would weaken the security boundary I was trying to build around KAL and could permanently affect Samsung Knox-dependent functionality.
Instead, I extracted the useful requirement hidden inside the idea: I still wanted a secure break-glass remote administration route for times when Telegram or the normal control path was unavailable. The better future design was Cloudflare Access → existing Tunnel → Termux SSH → Ubuntu → Hermes Agent → KAL-7, without a public SSH port and without rooting the phone.
What I learned
- Technical sophistication is not the same as suitability.
- Security changes must be judged across the whole system, not only by how strong one login method appears.
- Good architecture often means preserving existing security boundaries rather than bypassing them.
- A rejected design can still produce a useful requirement or safer alternative.
I was starting to ask not merely “Can this be done?” but “Does this belong in my system, and what would it cost in risk and complexity?”
Days 4 and 5 were when the automation ideas from the previous day started becoming part of a wider system.
On Day 3, I had been thinking about sources such as X and the simple pattern:
source → monitor → filter → alert
Now the question was becoming bigger. If outside services were going to communicate with KAL-7, how could I let that happen without unnecessarily exposing the AI environment running on my phone?
Designing the gateway
This was where Cloudflare entered the picture.
Cloudflare is an internet-facing security and connectivity platform. In my design, a Cloudflare Worker would act as the secure gateway between external services and KAL-7, rather than allowing those services direct access to the Hermes Agent environment on my phone.
The design centred on IFTTT + Cloudflare + KAL-7, and importantly, it was intended to work in both directions:
IFTTT → KAL
and
KAL → IFTTT
One route would allow outside events to reach KAL through the controlled gateway. The other would eventually allow KAL to trigger approved actions through IFTTT.
That second direction was important because I did not want KAL-7 simply to receive information. The longer-term idea was for her to be able to use the automation system as well.
The plan proposed giving KAL access to IFTTT’s MCP/API layer and a local capability registry. From there, she could eventually discover connected services, register triggers and actions, create or update applets, test capabilities and identify ones that were no longer working.
But there were boundaries. New OAuth or account permissions would still come back to me, and dangerous actions would require explicit approval.
And this was still a design rather than a finished self-managing system. The 24 next practical step was connecting KAL to IFTTT’s control layer and building the registry.
Seeing the system as a whole
By the following day, there were enough pieces that I needed to understand how they fitted together, rather than a collection of separate experiments.
The main stack was:
S24 Ultra → Android → Termux → Ubuntu 24.04 ARM64 → Hermes Agent/Gateway → KAL-7
Telegram provided the remote interface. Grok was the everyday model, with OpenAI Codex available as a fallback. Cloudflare protected external routes, while IFTTT formed part of the event-driven automation layer. Termux and supervisor/watchdog logic were also part of the Android integration and resilience thinking.
Two other ideas that were becoming important. One was email as a more durable archive alongside Telegram.
The other was a Research Library designed to make source material retrievable and useful rather than simply leaving documents sitting in a folder.
Backup and recovery were becoming more important too. Work on an encrypted OneDrive recovery package reflected a simple change in how I saw the project: it was becoming something I did not want to lose if the phone failed.
What changed in my thinking
The question was no longer simply:
What can I automate?
It was becoming:
How do I connect these things safely, let information move in both directions when appropriate, and keep the whole system manageable as it grows?
I was beginning to understand that the AI model was only one part of what I was building.
The connections around it, permissions, security, messaging, recovery and the way different services interacted mattered just as much.
What I was learning
I was starting to understand why the gateway mattered. An outside service did not need direct access to KAL-7 simply because it needed to send information to it.
I was also beginning to see the difference between connecting a service and allowing KAL to manage that service.
The IFTTT routes could provide the connection first. Giving KAL the ability to discover capabilities, create applets, test them and deal with failures was another layer that could be added afterwards.
By Day 5, I was also learning why documentation mattered. Once the project had enough moving parts, relying on my own memory to remember how everything fitted together was no longer realistic.
Looking back
Days 4 and 5 were probably the point where the project began to look like an actual architecture to me.
The simple monitoring idea from Day 3 was becoming something broader:
outside service → controlled gateway → KAL-7 → approved action
But the gateway was only one part of it.
Around KAL-7, I was beginning to assemble messaging, model routing, automation, security, knowledge and recovery into one phone-hosted system.
That was a significant change from where I had started only a few days earlier.
Day 3 was when I started applying the project to everyday information problems.
I was already using X, and I began thinking about how automation could sit alongside it: monitor for specific information, filter what matched, and alert me when something useful appeared.
The Area Alert and Bus Alert projects were early examples of this idea. Instead of repeatedly checking sources myself, I wanted the system to do some of that checking for me.
The pattern was simple:
source → monitor → filter → alert
At this stage, KAL-7 was not yet deeply connected to these automations, but the idea was starting to form that AI could eventually help decide what was important enough to bring to my attention.
What changed in my thinking
By Day 3 the question had become:
What repetitive checking could I hand over to automation?
I was starting to see that the value of KAL-7 was not only in answering questions, but in reducing the amount of attention I had to spend looking for the same information repeatedly.
What I was learning
I learned that useful automation often starts with a simple repeated task.
I also began to understand that alerts need filtering. Otherwise, automation can simply replace manual checking with notification overload.
Looking back
The Area Alert and Bus Alert projects introduced a pattern that would appear throughout KAL-7:
monitor something → detect something relevant → notify me when my attention is needed
@aibuilderhq_ I wasn’t thinking in terms like state consistency. I was still learning what all the different parts were doing.
Hermes definitely helped because it already had ways of keeping memory and context between sessions, so I wasn’t building all of that from scratch.
What happened
Day 2 was when the project started to move beyond the novelty of simply getting an AI agent running. The question became more practical: how could I use this system regularly and make it reliable enough to depend on?
Hermes Agent is the underlying agent framework and runtime on which KAL-7 depends. KAL-7 is the personalised orchestration layer I am building through it, including her identity, rules, integrations and workflows. The aim was no longer just to run an agent on a phone, but to create a system that could be reached remotely, recover from normal interruptions and use different models or tools when needed.
Telegram was beginning to emerge as the most practical way for me to interact with the system.
I also started to think more clearly about the role of each part of the system. The phone was the host. Android was the underlying operating system. Termux provided the Linux user-space environment, with Ubuntu running inside it. Hermes Agent then provided the agent runtime and tool framework through which KAL-7 operated. Language models provided reasoning, while external services gave me ways to reach the system and connect it to other platforms.
What changed in my thinking
On Day 1, the main question had been, “Can I run this?”
By Day 2, it had become, “How should these parts work together so that I can rely on the system?”
This was one of the first signs that I was beginning to think about the project as a complete system rather than a collection of separate tools. Individual features still mattered, but I was paying more attention to how they connected, what each component was responsible for and what would happen if one of them failed.
I was beginning to think in terms of architecture rather than simply setup.
What I was learning
I was beginning to understand that remote access to an AI agent did not necessarily require exposing the underlying agent environment directly to the Internet. Safer layers could sit between me, external services and the system itself.
I was also beginning to recognise that anything expected to run for long periods would eventually need supervision, startup routines and recovery mechanisms. Processes can stop, phones can restart and services can fail, so resilience would have to become part of the design rather than an optional extra.
Another lesson was the difference between having a fallback model and using several models for every request. A fallback provides resilience when the preferred model is unavailable or unsuitable. It does not mean that every task needs to be sent to multiple models.
Telegram also showed me that the interface I use does not have to be the same environment in which the system runs. KAL-7 could operate through Hermes inside her own technical stack while I interacted with her through a much simpler interface.
That separation would become increasingly important as the project developed.
That’s interesting. I’m still learning, so I’m not actually familiar with what you mean by keeping yours in rerun.
You’re right though that I’ve ended up with quite a few layers to keep alive before KAL gets to do anything 😅.
A lot of what I’ve been working on since has been supervision, health checks and getting things to restart reliably.
The other comment here has also made me think about something I hadn’t properly considered... restarting Hermes is one thing, but recovering a task that was halfway through when it died is another.
What are you using when you say rerun?
That’s actually a good question. At that stage I still had to step back in if Termux/Hermes actually went down.
I’ve since worked on making Hermes/KAL restart more reliably if the underlying process goes down, but I don’t currently have a general system for recovering a task that was halfway through when it happened.
So if a task had completed 3 out of 5 steps, I don’t yet have something that can always pick up safely from step 4 without risking repeating an action.
That’s something I need to think about properly.
I’m going to be honest, I’m still learning all of this, so I’m not completely sure what you mean by editing, state persistence and feedback in this context 😅
The hardest part for me was probably just getting everything to keep working reliably on the phone rather than getting something running once and then finding it had stopped, disconnected or needed restarting.
If that’s what you mean by state persistence, then definitely that.
What happened
This was Day 1 of the project. I started with a simple but ambitious question: could I turn my Samsung Galaxy S24 Ultra into the home of a persistent personal AI rather than simply use AI through separate apps?
The foundation that emerged was Android → Termux → Ubuntu 24.04 via proot-distro → Hermes Agent/KAL-7. At this stage, I was not approaching the problem as a conventional software developer. I was describing outcomes, testing instructions, observing what happened, asking why things failed and using AI to help me bridge the technical gaps.
What mattered was the shift in mindset. I was no longer simply asking an AI questions. I was beginning to build an environment in which an AI agent could have tools, maintain state and have a place to run continuously.
What I was learning
A phone can host a surprisingly capable Linux userspace without rooting Android.
The model and the agent framework are different things: Hermes can coordinate models, tools and interfaces.
A working system depends on the environment surrounding the AI, not just the intelligence of the model itself.
My role vs AI
I supplied the objective, made the decisions and performed the setup and testing. AI supplied much of the implementation guidance and command-level scaffolding. I did not suddenly become a software developer on Day 1; I began learning how to direct, evaluate and understand technical work.