• 

  Architecture

• 

person8 — a modular reasoning layer for AI agents

💡 Inspiration

It started as a search engine. I was trying to get AI agents to understand my company's context — and I kept hitting the same wall: the context, and the reasoning I'd built around it, was trapped inside one app, one session, one model. Every new agent started from zero.

Then I noticed the same problem in my own life. I'm an Indonesian citizen working in the US on a visa, and the information that actually applies to me is scattered across three countries' rules, my own documents, and regulations I've never heard of. No chatbot has my context, and I can't hold it all in my head.

Both are the same problem: memory tools port your facts, but the reasoning — how a conclusion was reached, what context it depended on — gets thrown away. person8 makes that reasoning portable and modular — a layer you carry between any agent.

⚙️ What it does

person8 is a compounding knowledge engine with a portable reasoning layer. Point it at your own material; it onboards you with a quick human-in-the-loop interview, builds a reasoning graph of your situation grounded in your data, and grounds every turn with a portable <preamble>. Reasoning itself is portable — you can import, bridge, and export domain graphs as a few kilobytes of JSON.

                ┌───────────────────────────────────────────┐
  you ────────▶ │  Antigravity  (skill plugins)             │
  drive &       │  /resume   /explore   /search   /bridge   │
  explore       └─────────────────────┬─────────────────────┘
                                       │ goal / explore
                                       ▼
                ┌───────────────────────────────────────────┐
                │  person8 agent                            │
                │  Google ADK · Gemini 3 · Cloud Run        │
                │  plan → search → extract → synthesize     │
                └──┬─────────────────────────────────▲──────┘
      search (read)│  + record findings → KB grows    │ grounds
                   ▼                                  │ every turn
      ┌───────────────────────────┐    builds   ┌────┴───────────────┐
      │  Elasticsearch (the KB)   │ ──────────▶ │  <preamble>        │
      │  Elastic Agent Builder    │             │  the reasoning     │
      │  MCP · hybrid RRF · 6 idx │             │  layer (portable)  │
      └───────────┬───────────────┘             └────────────────────┘
                  │
                  └──▶ you explore → it feeds back → the KB compounds  ⟲

In the demo, I tell it I want to build a skyscraper in London. It pulls two prebuilt rulebooks from the cloud and bridges them — surfacing the cross-border constraints that apply to me and that neither source holds alone:

  indonesia-outbound            BRIDGE              uk-construction
  ┌──────────────┐         ┌──────────────────┐       ┌──────────────┐
  │ BI · FX      │───┐     │ dual disclosure  │   ┌───│ ROE · owners │
  │ PPATK · AML  │   ├───▶ │ FX + AML          │◀──┤   │ HMRC · SDLT  │
  │ BKPM · FDI   │───┘     │ financing cap     │   └───│ EngC · CEng  │
  │ LPJK · lic.  │───────▶ │ licence portab.   │◀──────│ GLA / BSR …  │
  │ OJK · loan   │         └──────────────────┘       │              │
  └──────────────┘      4 findings neither graph       └──────────────┘
   (8 findings)          contains on its own            (9 findings)

The whole mission exports as one portable artifact — ~8 KB, gzips to ~2 KB.

🛠️ How I built it

Elastic is what builds the <preamble> — the synopsis spine, ranked findings, and coverage verdict that ground every turn — and it's where new findings are written back so the KB compounds.

🏆 Human-supervised learning loop

  THE COMPOUNDING LOOP
  ground from Elastic ──▶ HITL ──▶ write findings back ──▶ KB grows ──┐
        ▲                                                            │
        └──────────────── better preamble next turn ◀───────────────┘

• The compounding loop — knowledge actually compounds across runs instead of resetting, with an honest coverage verdict and a human in the loop.
• The bridge — cross-domain synthesis producing findings neither source holds alone (one payment that trips three reporting rules across two countries).
• True portability — a full cross-border reasoning graph is ~8 KB; reasoning you can version, move, and reuse like code.

📚 What I learned

Reasoning — not just facts — is the missing portable layer. Make context portable and modular, and a domain gets modeled once so anyone with the right situation can pull it in. Honesty (a coverage verdict) and a human-in-the-loop checkpoint beat letting a model guess, and grounding through a compact portable preamble keeps the agent fast and legible.

🚀 What's next for person8

  NOW  ──────────────────────▶  NEXT
  personal KB                   regulation sector
  enterprise KB (ad-hoc)        portable jurisdiction graphs
  → company supergraph          → import + bridge → compliance at the edge

I'm building out the enterprise and personal KB paths — deriving a reasoning graph ad-hoc per question and federating individual graphs into a company supergraph. Next is the regulation sector: regulators publishing portable jurisdiction graphs that anyone imports and bridges to check compliance at the edge — exactly the cross-border problem that started this.

Built With

• agent-builder
• antigravity
• cloud-run
• docker
• elastic
• elasticsearch
• gemini
• gemini-3
• google-adk
• google-cloud
• mcp
• model-context-protocol
• python
• vertex-ai