About CogniZhi

Who we are

Cognition and ZhiHui — wisdom. AI that reasons, not just responds.

The name CogniZhi joins Cognition with ZhiHui (智慧) — the Chinese concept of wisdom, deep understanding and intellect. It embodies our conviction that the next generation of AI must go beyond speed: it must reason, adapt, and act with genuine insight.

CogniZhi builds the intelligence and orchestration layers enterprises need to move past standalone chatbots and coding assistants. We were founded by engineers who have spent decades inside complex systems — firmware test benches, release pipelines, regulated platforms, blockchain infrastructure — and who kept meeting the same problem from different angles: the organisation knows more than any one person can reach, and AI is only as good as the part of it that it is allowed to understand.

Where we are today

Both platforms run on real code, and both are unfinished in places. Rather than a maturity badge, here is the part-by-part account: what is in daily use on our own estate, what is being sharpened, what is still being built, and what is a name on a design document.

Our own assessment, as of 16 August 2026 Running in daily use on our own estate In refinement built and working; being sharpened now In progress actively being built Built, not yet on finished, shipped switched off, being proven first Not started designed or named; no code yet
SydeKx

Understanding the estate, and deciding what may be said about it

  • Ingestion and retrieval

    Running

    Documents, source code, wikis and configuration in one permission-aware index, retrieved by hybrid vector and graph search. Every answer carries its source and version — the part the tour opens with.

  • The answering agents

    Running

    A layered agent fleet rather than one prompt: a facilitator routes, specialists retrieve and reason, and the whole chain of thinking and tool calls stays visible while it runs.

  • Compiled wiki

    Running

    An LLM-compiled wiki over documents, repositories and approved web sources, so a question about a system reaches a written explanation rather than only the code that implements it.

  • Repository intelligence

    Running

    Symbol-level parsing across twenty-plus languages into a code graph, with an MCP surface so the same retrieval works from inside VS Code, Cursor or Claude Desktop.

  • Synapse — the governed context graph

    In refinement

    The canonical model of the estate and its versioned projections, changed only through propose, review, merge and publish. Retrieval answers against a pinned version, which is what makes an answer reproducible months later. Built and working; the last review and rollout phases are what we are sharpening.

  • Deep code review

    In refinement

    Review of a branch or a pull request against versioned profiles, with contract-impact detection across repositories. Running against our own code; the cross-repo impact engine is the piece still being finished.

  • Sentinel — the correction loop

    Built, not yet on

    What happens when an answer is wrong: feedback becomes a trust-weighted signal, a case opens, a diagnosis is produced and an arbiter adjudicates it inside bounded governance. Complete, and deliberately shipped with every switch off — it watches on our own estate before it is allowed to act on anyone’s.

  • Dendrite — execution provenance

    In progress

    The turn-by-turn record of what the agent actually did — every delegation, retrieval and tool call — as one trace you can replay. This is the piece being built right now.

  • One agent, natively delegating

    Not started

    Collapsing the layered fleet into a single agent that delegates natively. Designed, argued about, and deliberately not started: the layering is what makes today’s behaviour inspectable, and we will not trade that for elegance until the replacement can be proven.

Vortex

Turning an approved idea into reviewed, merged code

  • The governed loop

    Running

    Idea to planning gate to ticketed execution to integration QA to a two-level merge, with a human in the loop exactly twice. This is the whole of what the Vortex tour walks through, and it runs against our own repositories.

  • The policy table

    Running

    Sixty transitions, each naming the single actor permitted to make it, compiled to policy and enforced at the boundary. An agent cannot take a step it was not authorised to take — not by convention, by construction.

  • Append-only audit

    Running

    One record per capability call, append-only at the database. The claim is not that the agents are good; it is that you will always find out what they did.

  • Role-specialised agent team

    In refinement

    Ten roles — planning, architect, implementation, design, validation, review and the rest — across four technology stacks, with several instances of a role able to work at once. Working; the role model itself is still settling.

  • Live previews

    Running

    Every sprint branch built into a clickable environment, so the review of a change is of the running thing rather than of a diff.

  • Cost, per run

    Running

    Token and cost accounting per run against per-project budgets — the answer to what the AI programme actually costs, rather than an anecdote.

  • Isolated per-agent containers

    In progress

    Each agent working in its own container rather than a shared checkout. The execution side runs; the final merge back still assumes the older shared-checkout path, so that is where the work is.

  • The recovery ladder

    Built, not yet on

    Six forward-only tiers for when an agent gets stuck, ending in a human escalation that can never be disabled. The first tiers and the last run by default; the middle tiers are complete but opt-in while we prove them.

  • Memory across long projects

    In progress

    Recall of past decisions and defects is wired in and injected automatically, so agents do not re-derive what was already settled. Retrieval is still keyword-flat; semantic recall is the next piece.

  • Elastic execution in your own cloud

    Not started

    Scaling to zero when idle inside a customer’s own cloud, and the per-tenant isolation that goes with it. Architected in detail, written down, and not built — today Vortex runs as a single deployment.

Both platforms are prototypes with real code running end to end, not slideware. We would rather hand you this list than have you discover it in month two — and a pilot uses the parts marked Running.

Guiding principles

  • Reason, don’t just react

    AI should understand context and consequence, not pattern-match its way to a confident answer.

  • Wisdom over automation

    Speed without judgement only creates new problems faster. Our systems are built to think, not merely to finish.

  • Accountable by construction

    Autonomy is only useful if it can be inspected. Permissions, provenance and audit belong in the architecture, never bolted on afterwards.

Our story

CY and SH first crossed paths on the engineering floor at Motorola Singapore. Two decades later they were comparing notes on the same frustration that had followed them through every role since: the hardest part of running complex systems is rarely the technology — it is that nobody can see how all of it connects. Between them they have worked the full span of it, from firmware and hardware test through development, release management and regulated infrastructure to AI platforms. CogniZhi is the layer they kept wishing existed: one that holds an organisation’s understanding in place, and lets AI act on it without anyone losing the thread.

Our founders

  • Co-Founder · CEO & Co-CTO

    SHL

    A builder of delivery systems and release practices who brings order to complexity without losing the hands-on instinct that made him effective in the first place.

    SH started in engineering management, standing up agile tooling and release teams from nothing. That early work defined his core strength: designing practical, scalable delivery processes that hold under real enterprise pressure rather than only on a slide. As the scope grew, so did the stakes — infrastructure, compliance technology and DevOps architecture inside heavily regulated environments, where a delivery decision and a control decision are the same decision. Across telecommunications, enterprise platforms, financial services, blockchain networks and AI systems, his instinct has stayed constant: build it properly, document it clearly, and leave behind something the next team can actually use.

    He leads CogniZhi with a conviction formed over twenty years of shipping under scrutiny: AI will only earn a place in serious organisations if its work can be inspected, explained and trusted by the people who carry the risk.

  • Co-Founder · CIO & Co-CTO

    CYY

    An engineer who moves comfortably from firmware benches to blockchain networks — and believes hard-won operational knowledge should never be allowed to quietly disappear.

    CY began in software test development and firmware integration, where he learned early that systems rarely fail the way their specifications promise. That foundation shaped everything after it: practical, deeply technical, and always aimed at connecting fragmented systems into something resilient enough to run. He went on to configuration management, enterprise release automation and large-scale DevOps transformation, building a reputation for taking operational complexity apart and giving teams back the time that process had been quietly consuming. Across manufacturing, telecommunications, financial services, Web3 infrastructure and AI platforms, he has stayed close to the tools, the platforms and the people doing the actual work.

    He co-founded CogniZhi on a simple premise: what an organisation knows should not live in old notebooks, siloed teams and institutional memory. It should be captured, connected, and turned into a foundation the next decade of work can be built on.

Founding team

The earliest people to join the founders in building CogniZhi into a business.

  • CWY

    Founding Member COO & Acting CFO

    Twenty years of turning enterprise technology into a working business — invited in as our earliest founding member to lead business development and investment.

    CWY has spent over two decades across technology, product and operations in global financial services and banking, leading product and engineering teams through the full build-and-run cycle of enterprise software. His work has spanned delivery, commercial and operational planning in equal measure — the specification and the shipping, but equally the pricing, the vendor terms, the run costs and the operating rhythm that decide whether a good product ever becomes a viable one. He has seen, from the inside, how enterprises actually evaluate, buy and live with software.

    He joined at the earliest stage to build the commercial side of CogniZhi in step with the engineering — so the platforms reach the right organisations, on the right terms, at the right moment.

CogniZhi

Get in Touch

Want to learn more or explore a partnership? Drop us a line.