Engineer · Author · Founder, DDSE Foundation
I work on enterprise software, decision-driven engineering, and the knowledge layer that AI agents actually need to operate. I write books and papers, run a small open-source foundation, and ship code under that same line of work.
Bangladeshi engineer and author. Two decades across data platforms, cloud-native systems, and SaaS. Founder of the DDSE Foundation; author of Enterprise AI: Strategic Blueprint for Purple People and The World of Active Things. Current research direction is agent-native knowledge modelling.
Photo: Rokon Emon
01 / Now
What I have published most recently — preprints, articles, and notes, newest first. Each item links directly to the primary source.
A methodology paper proposing AKMM — modelling knowledge as a world of bounded, stateful active things so agents can operate on the case directly instead of reconstructing it from fragments. Bounded methodology evidence from one anchor domain plus two transfer PoCs. Not industrially validated.
Two AI reviewers — Gemini Pro and ChatGPT Pro — were given the book with a structured prompt and asked for an independent critical assessment. Both prompts and full model responses are published verbatim, including the parts that were critical or uncertain. The point is transparency about how AI reads a technical argument, not endorsement of a positive verdict.
Toy agents demo well because they execute single tasks on forgiving inputs with no need to recover. Production agents face three harder requirements: recover from partial failures, hand off to other agents or humans with continuity, and remain observable under monitoring. The article argues all three converge on the same structural gap: an agent with no explicit model of its own state and lifecycle cannot do any of them reliably. State machines are not an architectural preference — they are the precondition.
Enterprise AI deployments tend to stall between the strategy deck and the working system — not because the model is wrong and not because the infrastructure is missing, but because the middle layer is never built. That middle layer must do three things neither the strategy nor the model can do alone: preserve decisions explicitly so they survive team and context change; enforce contracts so agent behaviour stays within intended bounds; and assemble context deliberately so the model operates on the right slice of the world rather than an unfiltered retrieval dump.
MCP is a protocol — a standard way for a system to address an LLM
through a defined structure — not synonymous with "MCP server".
A tool has two distinct halves: the schema (what the model sees:
name, description, parameters, required fields) and the command
(what the runtime executes). The model sees no code — only the
contract. The article opens with a concrete bug: one missing
required field in a tool schema caused a cascading night
of parser failures, and the fix was not a better prompt but a
correctly specified contract.
Written as the industry's language began converging on the same ground the frameworks already occupied. Three retrospective sections: DDSE — that AI-assisted software delivery requires structured decision records throughout the SDLC, not only code suggestion; ACM — that agent governance must be designed in as typed contracts and replayable ledgers before deployment, not added after problems appear; and CEF — that context is part of the engineering foundation, not a retrieval utility around it. The essay ends on an honest uncertainty: familiar lifecycle examples (O2C, P2P) may have made the deeper argument about decision spaces too easy to overlook.
The monograph behind AKMM. The argument is that knowledge about a thing becomes meaningful only when you first ask: what belongs to this thing as this thing? That is boundary. Then: how does it begin, move, relate, and end within that boundary? That is lifecycle. Current enterprise systems hold the data but hide the active thing behind fragments, status codes, and scattered process residue. The book develops the seven structural features — Start, End, States, Transitions, Events, Relations, Purpose — and the Identity Index as the minimum through which a thing becomes operable knowledge rather than a record cluster.
Subscribe via this site's RSS feed, or follow upstream sources directly: Medium RSS and the Hugging Face blog.
02 / Methods
A coherent stack for enterprise-grade agentic systems: DDSE for decisions, ACM for contracts and runtime, CEF for context, and AKMM for knowledge modelling. Each card states the scope boundary and links to the published source.
Methodology · 2026 · DOI & book
Models a knowledgebase as a world of Active Things with explicit boundary, lifecycle, identity, lived memory, canonical events, and purpose, so AI agents can operate on the case rather than reconstruct it.
Boundary. Bounded methodology evidence (one anchor, two transfer PoCs). Not an industry standard.
Methodology · 2025 · Site, DOI & repo
An SDLC where significant technical decisions are captured and governed as first-class artefacts (MDD, ADR, EDR, IDR, TDM), so AI-assisted development stays inside human authority and preserves architectural intent.
Specification & runtime · 2025 · DOI & repo
A spec-first contract layer for agentic systems: typed contracts, deterministic execution, and a replayable decision memory so agents can be reasoned about, not just observed.
Framework · 2025 · Repo (research-grade)
An ORM-style framework for LLM context: relationship-aware context assembly over knowledge models with graph and vector persistence. Intended as a research foundation, not a hardened product.
Book framework · 2024 · DOI
The framework behind Enterprise AI: Strategic Blueprint for Purple People: decision-domain inventory, profiling, and an AI Effectiveness Index derived through PCA over scored decision domains.
Architecture & framework · 2018–2019 · Repo & articles
Java PWA and microservice platform with Netty/Jersey, an API gateway, and event-driven SPA shell — the architectural backbone of the CloudOffice digital workplace work.
03 / Books & papers
Five books and ten preprints I have written, covering knowledge engineering, AI methodology, software architecture, enterprise strategy, philosophy, and governance. Preprints expand with full abstracts; the complete record is on ORCID.
Proposes that knowledge engineering for agents requires boundary analysis — defining where a thing starts, ends, relates, and what its purpose is — as the first modelling step, before lifecycle or state work begins. A knowledgebase composed of Active Things gives an agent an entry point into a case rather than forcing reconstruction from disconnected records and documents. Seven structural features (Start, End, States, Transitions, Events, Relations, Purpose) constitute the Identity Index of any Active Thing. Evidence is bounded to one anchor domain plus two transfer PoCs; not industrially validated.
Article · Book
Where most agent frameworks treat goals, plans, and tools as prompt constructs, ACM defines them as typed artefacts with explicit lifecycle states, guard conditions, capability maps, and a replayable ledger. The effect is that agent behaviour can be inspected, replayed, and reasoned about — not only observed after the fact. The specification includes a TypeScript reference runtime and is published under the DDSE Foundation.
GitHub · Article
Argues that AI-assisted development fails when the AI lacks the structured context experienced engineers carry implicitly. DDSE's answer is to make significant technical decisions — architectural, engineering, incident, technology — first-class artefacts (ADR, EDR, IDR, TDM, MDD) that persist across team changes and remain the explicit boundary within which AI operates. Humans retain authority; the AI uses decision records as context, not discretion.
Foundation site · DDSE vs SDD
A hybrid architecture for closing gaps in structured knowledge: a symbolic knowledge graph identifies where conceptual connective tissue is missing, GPT is queried incrementally to propose bridge concepts, and the proposed chain is validated and reintegrated into the graph. The cycle iterates until the gap narrows below a threshold. Frames the problem as one of convergence, not generation — the LLM fills specific holes rather than generating freeform explanations.
A practical mapping of ML integration patterns for enterprise engineers working with existing Java/microservice systems. Covers sidecar inference, async event-driven ML triggers, API bridge patterns, and the deployment lifecycle differences between ML models and conventional software artefacts. Addresses the common failure mode of treating an ML model as a library call rather than as a separately versioned, separately deployed runtime.
Applies Descartes' four rules — decompose, order, enumerate, review — as a reasoning discipline imposed on GPT. The central question is whether a Cartesian audit structure (accept nothing unexamined; divide each difficulty; proceed from simple to complex; enumerate to ensure completeness) produces more reliable, less confabulated responses on complex reasoning tasks than open-ended prompting. A methodological experiment in structured epistemic discipline applied to large language models.
The DOI-backed preprint behind There Are Seasons of the Mind. Models human mental resilience through three physics metaphors: entropy (sustained effort without deliberate renewal degrades capability), inertia (initiating change requires activation energy beyond intention alone), and equilibrium (performance requires balance between challenge and recovery). Integrated with Stoic self-regulation and Viktor Frankl's will-to-meaning as practical counterweights to each physical force.
Book
Argues that the engagement-maximising design of current social platforms is not technologically inevitable — it is a deliberate architectural choice. Proposes an alternative set of design principles oriented toward transparency, contribution, and civic participation that could redirect the same attention infrastructure toward measurably better social outcomes, without requiring platform replacement.
Distinguishes between activity (visible motion through tools, meetings, and status updates) and productive work (directed effort that moves a stated goal forward). Examines the structural conditions — notification design, meeting culture, tooling overhead, and fragmented context — that make high-activity, low-output environments self-reinforcing, and why individual willpower is an insufficient corrective.
The "single neck to choke" management model concentrates accountability at one person as a mechanism of control. This paper argues the model is structurally incompatible with networked, cross-functional work — and with Gen Z's expectation of distributed ownership — because it optimises for blame assignment over problem resolution, damages trust faster than it creates accountability, and collapses under the ambiguity of modern product delivery.
Full record on ORCID.
04 / Code
Public repositories I maintain or have authored. DDSE Foundation repos are open-source infrastructure I built for the methodology; personal repos span platform architecture experiments, reactive frameworks, and research tooling.
Agentic Contract Model — a spec-first contract layer for agentic systems. Where most agent frameworks treat goals, plans, and tools as prompt constructs, ACM defines them as typed artefacts with explicit lifecycle states, guard conditions, capability maps, and a replayable decision ledger. Agent behaviour can be inspected and replayed, not just observed after the fact. Ships a TypeScript reference runtime under the DDSE Foundation.
Context Engineering Framework — an ORM-style layer for LLM context assembly. Moves beyond retrieval by modelling knowledge as typed entities with relationships, lifecycle, and semantic distance. Combines graph and vector persistence, relationship navigation, parser systems, and LLM integration so that context is assembled deliberately rather than retrieved as a flat embedding result. Marked as a research edition; not enterprise-hardened.
DDSE implementation templates, decision record formats, and worked examples for teams adopting Decision-Driven Software Engineering. Covers the full set of DDSE artefact types — Architectural Decision Record (ADR), Engineering Decision Record (EDR), Incident Decision Record (IDR), Technology Decision Map (TDM), and Master Decision Document (MDD) — with guidance on how each fits into an AI-assisted development workflow where humans retain authority.
Java PWA and microservice development platform from the CloudOffice digital workplace work. The architecture centred on a Netty 4 HTTP/2 API gateway routing to Jersey microservices, with a bck2brwsr-compiled browser-side SPA shell, a gadget SDK for composable UI modules, and a SASS/JSON theme and layout builder. A 2018–2019 article series documents the design choices behind the gateway, reactive push communication, stateless process claims, and session/token security.
Multi micro-frontends and backends — a five-session build of a cloud-agnostic microservice ecosystem. Stack: Spring Boot services, Traefik reverse proxy, Keycloak auth, Consul service discovery, Kafka messaging, Angular microfrontends, Prometheus and Grafana observability. The central constraint is portability: the same system runs on a developer machine, in Docker Swarm, and on any Kubernetes provider without environment-specific changes. Original repository under the kareegor organisation (also owned).
Cloud-agnostic ML pipelines extending the same portability constraint from microservices into the ML layer. Uses Apache Beam with an Apache Flink runner on Minikube and MinIO as object storage, so the same pipeline code runs locally and can target any cloud-hosted Beam runner without vendor lock-in. Companion to the nine-part cloud-agnostic platforms article series.
Step-by-step build of a fully local, offline text-to-speech system using Nvidia NeMo and the FastPitch acoustic model. Documents the full pipeline from model download and environment setup through inference and audio output — useful for engineers who need production-grade TTS synthesis without a cloud dependency or per-request API cost.
Builder pattern implementation using Java functional interfaces to enforce strict immutability after construction. Rather than relying on defensive copying or convention, the pattern makes mutation structurally impossible through the interface contract itself — a useful reference for teams designing domain objects that must be safe across concurrent and event-sourced contexts.
05 / Demos & talks
Short, unproduced recordings — agent runs, architecture walkthroughs, framework demos. Hosted on YouTube under @PurpleThinkers; included here as artifacts of the working method, not as productions.
06 / Writing
Over 80 pieces I have written across enterprise AI, software architecture, platforms, leadership, governance, ESG, and philosophy. Entry points by topic below; the full corpus is on Medium across 13 curated collections.
07 / Arc
Twenty years of the same founding-architect pattern: I enter a greenfield, form the team, ship the platform, and hand over a running system. Five phases, ten engagements, six countries.
Database-driven enterprise applications; grounded early architecture instincts in schema design, SQL-heavy ORM patterns, and application-layer data access.
Designed and built a Data Warehousing Studio — an IDE for schema design, ETL pipeline construction, and semantic-layer modelling on Oracle 9i with Java Swing. National newspaper recognition.
Supervised the highest-performing final-year engineering projects in the programme; returned later as mentor and advisor. First evidence of the teaching-while-building pattern that continues throughout the career.
Bootstrapped a BI and portal services studio with 10+ second- and third-year CIS students. Delivered 50+ client projects worldwide via oDesk and Elance. Stack: Pentaho BI, Liferay, Java, PHP. First iteration of the team-building-from-scratch pattern.
Founding architect of the Oulu Municipality collaboration portal. Prototyped in 3 months, won the engagement; built a 12-engineer Java offshore team in 9 months. Liferay, Alfresco ECM for document management, Openfire XMPP for real-time messaging, CAS + OpenLDAP single sign-on.
Team lead and main architect for the Bugaboo global collaboration portal: 53 countries, 17 languages. Built a 10-engineer Pune team in 8 months. Led architecture, technology roadmap, integration strategy, code reviews, and on-site training across Amsterdam and India.
2nd Phase Lead Architect of Dzoin — a multi-million Euro real-estate management platform for Dutch property associations. Cloud-agnostic DevOps environment; modules: document management, CRM, social calendars, project tracking, site builder, content management.
Founding technical leader for a ground-up manufacturing ERP spanning Babylon Group's 19 factories. Recruited and led a 28-developer Java team from mixed seniority. Introduced Agile methodologies, CI/CD pipelines, environment virtualisation, and BI/analytics capability.
Started as founding architect of a national networking platform for Dutch mental health institutes; evolved into a generic cloud-agnostic digital workspace platform. Java JSON-service backend, multiple PWA frontends, Netty 4 HTTP/2 API gateway (Cockpit), Jersey microservice SDK, bck2brwsr browser model, drag-and-drop site builder, document management, workflow approval, real-time GPS tracking, form builder, and reporting dashboards. Integrated with Liferay and Apache OFBiz for enterprise extension. Recruited and grew the 16-engineer team.
Re-architected a conversational AI platform with engineers working directly across Bangladesh, Germany, and Japan. Introduced a reliability taxonomy, rebuilt the ML pipeline around it, established MLOps for model deployment, applied 12-factor app principles, and set up a new CI/CD workflow that significantly accelerated release cycles across the distributed team.
Designed a cloud-native microservices architecture with no single point of failure: Kubernetes with Traefik ingress, Consul service discovery, Keycloak SSO with Active Directory integration, Spring Cloud services. Mentored distributed teams on Agile and Extreme Programming practices.
Chief architect at ADN Telecom's digital unit. Architected Roboket Marketing Platform — a campaign and customer journey execution backbone for telecom-grade digital marketing operations. Restructured the software development process, introduced Agile, and modernised the technology stack.
Machine learning, API design, and data architecture advisory for a startup product team. Shaped the solution blueprint for scalability and ML-driven feature integration; mentored engineers on architecture principles and model deployment practices.
First hire and founding architect of EY's Client Technology product unit — a product organisation built inside a Big-4 firm. Designed the foundational platform stack on which 4+ SaaS platforms are now built and running across service lines. Cloud-native, multi-cloud architecture with Agile engineering standards. Grew the organisation from one person to 70+ engineers. Currently serving as Principal Architect for the CTO Office.
Founded the DDSE Foundation to formalise Decision-Driven Software Engineering as an open methodology. Produced ACM (Agentic Contract Model), CEF (Context Engineering Framework), decision record template standards, and the underlying papers on enterprise AI governance, agent system design, and active knowledge modelling.
08 / Terms
Terms I use across my work, grouped by the framework or methodology they come from. Each definition links to the primary source where the term was introduced.
09 / Connect
Where to find me: ORCID for DOI-indexed research, GitHub for code, Medium for long-form writing, Hugging Face for ML-adjacent articles and preprints, LinkedIn for professional context.