Date: 2026-05-10
Status: Draft paper for technical, academic, incubator, and enterprise diligence review
Audience: technical reviewers, academic collaborators, incubators, enterprise architecture teams, early technical investors

Research note: draft strategic material for founder, advisor, incubator, and investor review. External use requires human approval and current fact-checking.

Abstract

Agent88 is private agentic infrastructure for enterprise workflow orchestration. It combines persistent company memory, repeatable SkillMD operating procedures, governed task management, role-specific agents, and real execution through APIs and tool integrations. The system is designed to move beyond prompt-based chatbot usage toward auditable operational workflows: research, document generation, campaign proofing, proposal production, funding navigation, CRM follow-up, and future physical-production coordination.

The central technical claim is that useful enterprise agents require two foundations: procedural reliability and execution capability. Agent88 addresses procedural reliability through SkillMDs: structured operating playbooks that encode repeatable workflows, acceptance criteria, guardrails, and escalation rules. It addresses execution capability through APIs and integrations: Google Workspace, browser/computer-use, OCR/document parsing, GitHub, Telegram, Kanban, model providers, website deployment, and future physical-AI interfaces.

1. Problem Statement

Most AI adoption inside companies remains stuck at the chat layer. A user asks a model for a draft, summary, or suggestion; the user then manually moves the output into documents, spreadsheets, email, CRM, websites, reports, or approval workflows. This creates several enterprise failure modes:

Stateless context: the model forgets company decisions, client history, templates, preferences, and prior corrections.
Procedural drift: the model performs the same workflow differently each time.
No governance: tasks are not assigned, prioritized, blocked, reviewed, or audited like normal company work.
No execution: the AI can suggest work but cannot reliably fetch files, operate tools, update documents, generate decks, or create deliverables.
No approval boundary: external sends, procurement, legal/commercial claims, and client deliverables lack formal human gates.
No compounding IP: successful work is not converted into reusable procedures or product modules.

Agent88’s thesis is that enterprise-grade agentic orchestration requires an operating layer above models: memory, procedures, governance, execution integrations, and audit trails.

2. System Thesis

Agent88 is built around the following thesis:

SkillMDs define the procedure. APIs perform the work. Kanban governs the work. Hermes remembers the work. OpenClaw executes the work. Humans approve risky work.

This creates a governed agentic operating system, not a loose swarm of prompts.

3. Technical Stack Overview

Human Board / Operator
→ Hermes memory + synthesis
→ Kanban / Paperclip governance
→ role agents with SkillMDs
→ OpenClaw / tools / APIs for execution
→ reviewer + approval gates
→ outputs, logs, memory updates, reusable modules

3.1 Human Board

The Human Board is the accountability layer. It approves:

client-facing deliverables,
external messages,
spend and procurement,
legal/commercial claims,
client data access,
scope changes,
investor/incubator-facing materials.

Agent88 does not remove humans from responsibility. It removes repetitive work from the path between human intent and completed work.

3.2 Hermes — Memory and Synthesis Layer

Hermes provides continuity across chats, files, sessions, tasks, and decisions.

Functions:

persistent user/company memory,
MemPalace markdown source-of-truth integration,
meeting and document synthesis,
CRM and research distillation,
skill/playbook extraction,
Telegram and API-facing operator interface,
scheduled automations and digests,
self-improving memory/SkillMD loop.

Strategic value:

reduces stateless model drift,
preserves institutional memory,
turns client work into reusable IP,
lets the system learn from each run.

3.3 Kanban / Paperclip — Governance Layer

Kanban currently acts as Agent88’s Paperclip-like task manager.

Functions:

task decomposition,
role assignment,
priority and dependency tracking,
blocked states,
runtime discipline,
audit trail,
approval checkpoints,
worker handoff records.

Core lifecycle:

triage → ready/todo → running → blocked/done/archive

Governance principle:

Broad ideas stay in triage.
Only approved bounded work moves to execution.
Any risky action blocks for human approval.

3.4 SkillMD Layer — Procedural Memory

SkillMDs are reusable operating procedures for agents. They encode:

when to use the procedure,
required inputs,
expected outputs,
step-by-step execution pattern,
tool/API requirements,
acceptance criteria,
pitfalls,
safety boundaries,
verification steps,
escalation rules.

Without SkillMDs, agents improvise. SkillMDs turn repeated work into repeatable operations.

P0 SkillMDs already needed:

agent88-commercial-ops — CRM, CBDO, strategic investing, outreach, investor/incubation drafts.
kanban-orchestrator — goal decomposition, task governance, worker routing.
kanban-worker — bounded execution, blockers, logs, acceptance criteria.
ocr-and-documents — PDFs, scans, decks, legal docs, client samples.
google-workspace — Drive, Docs, Sheets, Gmail workflows.
powerpoint — pitch decks, proof reports, proposal decks.
webhook-subscriptions — event-driven workflows from files/forms/CRM triggers.
agent88-geo-visibility — answer-engine visibility and website positioning.
GitHub workflow skills — product engineering, repo diligence, release discipline.

P1 SkillMDs to formalize:

agent88-litepaper-variant-generator
agent88-investor-data-room-agent
agent88-rds-screencap-agent
agent88-proposal-document-agent
agent88-research-ingestion-agent
agent88-funding-navigator-agent
agent88-physical-production-coordination-agent
agent88-approval-gate-agent
agent88-client-onboarding-agent
agent88-proof-pack-agent

3.5 OpenClaw — Execution Plane

OpenClaw is the hands layer. It enables agents to operate across:

files,
browsers,
APIs,
dashboards,
shell commands,
documents,
websites,
screenshots,
local and remote machines,
future edge/physical workflows.

Strategic value:

moves AI from advisory output into completed work,
lets agents generate real artifacts,
supports private/client-specific execution environments.

3.6 API and Integration Layer

APIs are the difference between an AI assistant and an operating agent.

P0 integrations:

Telegram Bot / gateway — live operator surface and approval channel.
Google Workspace APIs — Drive, Docs, Sheets, Gmail, Calendar/Meet where possible.
Hermes Kanban CLI/API — task governance and audit layer.
Model APIs — OpenAI, Anthropic-compatible, local or routed models; model-agnostic design.
OCR/document parsing — local or API-based document extraction.
Browser/computer-use execution — screenshots, web workflows, proof generation.
GitHub API — product code, issue tracking, releases, technical diligence.
Website/CMS/deploy APIs — demo pages, litepapers, proof showcases, GEO pages.

P1 integrations:

Notion / Airtable / CRM,
Slack / Discord / WhatsApp Business,
Dropbox / OneDrive / SharePoint,
DocuSign / Adobe Sign,
Stripe / Xero / QuickBooks / Airwallex,
HKSTP / Cyberport / HKPC / BUD source monitoring,
vector DB: Chroma / Qdrant / Pinecone / pgvector,
monitoring: PostHog / Sentry / uptime / cost telemetry.

4. Agentic Technical Org Chart

Agent88’s agents are not arbitrary personas. They are role-based operational units with bounded skills, tools, memory, and permissions.

Human Board / Founders
│
├── Main Hermes / COO Agent
│   ├── memory, synthesis, routing, operator interface
│   └── doctrine, skill creation, cross-session continuity
│
├── PM / Orchestrator Agent
│   ├── task decomposition
│   ├── acceptance criteria
│   ├── Kanban routing
│   └── dependency management
│
├── Research / Intelligence Agent
│   ├── link/PDF/social/news ingestion
│   ├── evidence summaries
│   ├── tagging and priority scoring
│   └── routing to CRM/Kanban/website/proposal
│
├── Sales / CBDO Agent
│   ├── lead research
│   ├── CRM updates
│   ├── follow-up drafts
│   └── opportunity-to-workflow mapping
│
├── Proposal / Document Agent
│   ├── meeting notes → proposal scope
│   ├── Drive folders → module tables
│   ├── pricing context → quote drafts
│   └── follow-up messages
│
├── RDS / Proofing Agent
│   ├── campaign assets → visual proof reports
│   ├── screenshot/mockup generation
│   ├── PPT/PDF proof packs
│   └── QA checklist
│
├── Funding / Incubation Agent
│   ├── programme discovery
│   ├── eligibility screening
│   ├── missing-doc checklists
│   └── Cyberport/HKSTP/HKPC/BUD drafts
│
├── Investor Data Room Agent
│   ├── litepaper variants
│   ├── proof assets
│   ├── FAQ and diligence tracking
│   └── investor update packs
│
├── GEO / Visibility Agent
│   ├── answer-engine visibility checks
│   ├── website/GEO audits
│   ├── competitor signals
│   └── content/technical recommendations
│
├── Engineer / Product Agent
│   ├── integrations
│   ├── dashboards
│   ├── module code
│   └── release discipline
│
├── Ops / Security Agent
│   ├── runtime checks
│   ├── backups
│   ├── logs/cost telemetry
│   └── access boundary audits
│
├── Physical Production Coordination Agent
│   ├── supplier search
│   ├── RFQ generation
│   ├── quote comparison
│   ├── file handoff
│   └── human-approved orders/logistics
│
└── Reviewer / Approval Gate Agent
    ├── hallucination checks
    ├── evidence/source checks
    ├── commercial/legal risk checks
    └── final human approval routing

5. Academic Model: Workflow Orchestration Cycle

Agent88 workflows follow a repeatable orchestration cycle:

Intent capture
→ context retrieval
→ procedure selection
→ task decomposition
→ role-agent execution
→ artifact generation
→ review and verification
→ human approval
→ delivery or draft handoff
→ memory and SkillMD update

5.1 Intent Capture

Input can arrive through natural language:

Telegram messages,
voice notes,
meeting transcripts,
file drops,
URLs,
screenshots,
client folders,
emails/forms/webhooks.

5.2 Context Retrieval

Hermes retrieves:

company doctrine,
prior decisions,
client notes,
workflow templates,
active Kanban state,
relevant SkillMDs,
source documents.

5.3 Procedure Selection

The system chooses the relevant SkillMD. If no SkillMD exists, the workflow becomes a candidate for formalization after successful completion.

5.4 Task Decomposition

Kanban/Paperclip decomposes the goal into bounded tickets with assignee, priority, acceptance criteria, dependencies, and approval boundaries.

5.5 Execution

Role agents use OpenClaw and APIs to perform work across files, browsers, documents, websites, code, and external systems.

5.6 Review

Reviewer agents check for:

unsupported claims,
missing citations,
wrong client context,
formatting issues,
policy/commercial risk,
scope creep,
approval requirements.

5.7 Human Approval

Humans approve risky or external actions:

client deliverables,
spending/procurement,
legal/commercial claims,
investor/incubator documents,
public website changes.

5.8 Learning Loop

Successful workflows produce:

updated memory,
improved SkillMDs,
proof packs,
reusable module specifications,
future automation candidates.

6. Deployment Architecture

Agent88 supports multiple deployment modes:

Mode A — Agent88-managed workspace pilot

Fastest for early pilots. Agent88 runs the workflow from Agent88-controlled runtime surfaces and produces draft artifacts for review.

Mode B — Client-owned local appliance

Mac mini or office machine with scoped workspace access, Tailscale/remote support, local file processing, and client-owned physical control.

Mode C — Client cloud/VPS runtime

Dedicated cloud runtime for webhooks, dashboards, scheduled jobs, APIs, and always-on integrations.

Mode D — Hybrid deployment

Cloud/VPS orchestration plus local appliance for private files or office-local workflows.

7. Technical Roadmap

Phase 1 — Foundation

Kanban as Paperclip-like governance.
Formalize P0/P1 SkillMDs.
Harden Google Workspace, OCR, PowerPoint, browser/computer-use.
Package RDS Screencap and Proposal/Document workflows.

Phase 2 — Paid pilots

Client onboarding SkillMD.
Approval-gate SkillMD.
Proof-pack SkillMD.
CRM/payment/e-signature support.

Phase 3 — Platformization

Client portal/API dashboard.
Vector retrieval per client workspace.
Monitoring, cost, and audit exports.
Cloud/private/edge deployment playbooks.

Phase 4 — Physical AI bridge

Physical production coordination SkillMD.
RFQ, quote comparison, file handoff, human-approved ordering.
3D/CNC/logistics APIs only after real partner workflow is chosen.

8. Research Contribution

Agent88 contributes a practical architecture for enterprise agent orchestration:

procedural memory through SkillMDs,
task governance through Kanban/Paperclip,
execution through API/tool integrations,
institutional continuity through Hermes/MemPalace,
bounded role agents instead of one mega-agent,
human approval as a first-class architecture layer,
workflow outputs converted into reusable module IP.

9. Conclusion

Agent88’s technical architecture is not a single chatbot and not an uncontrolled swarm. It is a governed agentic operating system for company workflows. The platform’s defensibility comes from its accumulated SkillMD library, integration layer, client workflow modules, approval/audit system, and proof that real business workflows can be converted from natural language intent into completed, reviewable work.

Agent88 Technical Architecture and Agentic Org Chart