Insights & Thought Leadership
Enterprise AI strategy, private infrastructure, and agentic workflows.
From a Security Incident to Reconsidering Enterprise Agent Boundaries
An agent on EyWALink read a sibling tenant’s credentials off the shared host and listed their staff. The control plane’s 403 boundary was real but bypassable, because every tenant ran as the same OS user. Here’s the isolation ladder, and the tier that actually enforces it.
11 min read
The Cost of Running an AI Lab in Local AI
Eight months running an AI lab locally: the GPU-as-capex cost model, the engine path from vLLM to SGLang, and why prefix caching — not raw speed — is what made five tenants and twenty projects affordable on one box before shipping to clients.
9 min read
From One Agent to a Company of Agents
A coding agent is a tool you invoke. A company of agents is a system that runs. I built EyWALink as an AI company where every role — CEO, content author, engineer — is an agent, and found that the hard part was never the model. It was the control plane: issues, heartbeats, budgets, org trees. This post maps what it takes to run agents as employees, and what enterprises need before they hire their first one.
12 min read
Effective diagram tools for agentic enterprise architecture
AI agents generate enterprise architecture content at a rate no diagram toolchain can keep up with. In Agentic Executable EA, agents produce capability maps, application landscapes, data-flow diagrams, and transition waves across TOGAF ADM phases and Open Agile Architecture. The bottleneck was never the modeling language. It was to maintain the balance to serve two audiences, humans and agents: a human architect who needs to review, challenge, and present the result, and an agent that must parse the structured source to generate scaffolding and execution plans.
11 min read
When Your Agent Says “Done”
My verification script once marked a half-finished project complete. That ended the trust-based workflow. Now completion is an observable fact: a task queue, executable checks, a cron runner, and exit codes. This post traces the five-stage evolution from trust to evidence, and the meta-verification that keeps the verifier itself honest.
7 min read
Open Agile Architecture Overlay is released for agile digital transformation
ArcKit OAA turns the Open Group’s agile C208 standard into machine-executable architecture sprints: TOGAF for the baseline, O-AA for the velocity. Five commands and one build recipe deliver sprint-based, product-driven architecture work, with structured intake interviews that keep hallucination out by construction.
7 min read
How I Built a Digital Twin of Myself That Actually Scales
Four iterations to build a digital twin that actually scales: static snapshot, single-source memory in Qdrant, adaptive learning with Mem0, and graph understanding with Neo4j. Each phase solved a real bottleneck from the previous one, resulting in a localised system where agents can query who I am, what I know, and how I think.
6 min read
Why Zero Lock-In Matters for Enterprise AI
Vendor lock-in in enterprise AI looks like proprietary APIs, data residency risks, and cost spirals. Zero lock-in means sovereignty: the ability to move workloads between providers, self-host when needed, and maintain full ownership of data and models. This post walks through the open-source stack (SGLang, Qdrant, LangGraph, MCP) that makes it real.
5 min read
Private AI Must be part of the Enterprise AI Strategy
The real strategic question isn’t ‘which LLM vendor?’ It’s ‘who owns your AI intelligence?’ Exclusive cloud AI creates compliance exposure and fragments organisational learning. A private-core, cloud-edge architecture delivers data sovereignty, predictable economics, and a compounding competitive moat. Here’s the case for making private AI a core strategic pillar.
5 min read
Managing Context Overflow in AI Coding Agents
Context overflow kills coding agent sessions mid-task. The fix isn’t bigger context windows. It’s architecture. This post covers handoff files, subagent delegation, task decomposition, and wiring it all into AGENTS.md so coding agents stay productive across session boundaries without losing work to context limits.
4 min read
Bridging the E2E Testing Gap: Introducing SuperWeb Testing
AI coding agents write features and merge PRs at speeds no human QA team can match, but they don’t verify their own work. SuperWeb Testing closes the gap with a four-phase pipeline that connects source analysis, test data generation, browser automation, and server log correlation into a single traceable workflow.
7 min read
Observability Stack: Architecture for multi-agent AI systems
Autonomous AI agents are producing systems too complex for a single human to track. This post walks through a self-hosted observability stack (Prometheus, Grafana, Phoenix, Loki, and the OpenTelemetry Collector) that gives end-to-end visibility into agent systems, from LLM calls through workflow orchestration to the applications they produce.
8 min read
Manage Your AI Agents at Enterprise Scale
Enterprises are deploying hundreds of AI agents but most lack a systematic way to govern, secure, and orchestrate them. The ArcKit Agent Architecture plugin brings Enterprise Architecture methodology to agent programmes, providing inventory, design, governance, security, and maturity workflows through six slash commands and a six-phase build recipe.
5 min read
Executable Enterprise Architecture - Agentic-TOGAF-ADM
TOGAF ADM is the most widely adopted enterprise architecture framework, yet most teams can’t operationalise it without a dedicated EA team. ArcKit’s open-source update turns TOGAF ADM into agent-readable slash commands and build recipes, making architecture delivery executable, auditable, and repeatable, without a six-figure consulting budget.
6 min read
Practice of AI agent workflow patterns
Building software with AI agents means running iterative, self-improving loops instead of writing prompts by hand. This post distils three dominant LangGraph orchestration patterns: central orchestrator, LangGraph-as-orchestrator, and hierarchical subgraphs, compares their trade-offs, and shows how to bake human-in-the-loop and self-improvement into the design.
9 min read
Why I build my local AI with less spend on AI Subscriptions
2026 is the year of agentic AI. I made a deliberate shift: instead of burning cash on monthly Claude and OpenAI subscriptions, I invested in a local workstation running open-source models. Six months and billions of tokens later, this is less cost-cutting and more a strategic pivot. Here’s why, and why enterprises should consider it too.
4 min read
Buy Over Build? Rethinking IT Strategy in the AI wave
For two decades, ‘buy over build’ was enterprise IT’s default. AI has broken that equation: AI-assisted coding and composable platforms have collapsed development timelines and marginal costs. This post replaces the buy/build binary with a strategic framework, buy, build, or compose, and a transition playbook for architects ready to move.
4 min read
The Impossible Triangle: Speed, Memory and Intelligence
LLMs face a fundamental trade-off: speed, memory, and intelligence pull in different directions. Tuning local models taught me that you can optimize two corners of this triangle but the third always suffers. This post maps the triangle, mirrors it against human cognition, and shows how to pick the right corner to optimize for your workload.
3 min read
Private AI Is Production-Ready
After two years renting commercial AI, I shifted to building private AI on open source stacks, pushing billions of tokens through local silicon. Here’s the infrastructure, tooling, and workflows that made it production-ready, and what actually matters when you ship real systems locally.
5 min read