GhostBoard

Inspiration In traditional enterprise software, the "Brain" (the AI) is often treated as a third-party guest—an API call made from a stateless backend, parsed into JSON, and forced into a rigid frontend state. We found this architecture fundamentally "deaf" to the nuances of complex crisis management.

Our inspiration for GhostBoard was to move away from the "glued-together" architecture of modern web apps and create a Unified Intelligence Organism. We wanted a command center where the data doesn't just sit in a database, but lives within a sentient Knowledge Graph, and where the AI isn't just an external service, but a native capability of the language itself.

What it does GhostBoard is an AI-Native Crisis Command Center. It simulates a boardroom of specialized "AI Executives" (CEO, CTO, Security, HR, Operations, and Marketing).

When an enterprise crisis is triggered (e.g., "Tokyo cluster latency breach" or "Unauthorized API flood"), GhostBoard doesn't just display a static alert. It dispatches an autonomous agent (a Walker) to traverse the company's Knowledge Graph. As it visits each Executive node, that AI analyzes the crisis through the lens of its specific role, generating strategic, data-driven reasoning in real-time. Finally, it synthesizes these specialized insights into a cohesive Global Intelligence Report.

How we built it We built the entire platform using the Jac Programming Language to leverage its AI-native architecture.

Object-Spatial Programming (OSP): We modeled the application as a directed graph. The Executives and System Metrics are persistent nodes. G = (V, E) Where V represents our AI Executives and E represents the flow of intelligence between them. Meaning-Typed Programming (MTP): We eliminated traditional prompt-engineering and JSON parsing by using Jac's by llm() syntax. We typed our executive reasoning directly into the language, allowing the compiler to handle the LLM interaction securely. Walkers over APIs: Instead of the frontend polling a REST API, we use Jac walkers (like OrchestrateCrisis and SyncSystemStatus) to traverse the graph, update metrics, and trigger AI reasoning with a computational complexity of $O(V + E)$. Full-Stack Unified Codespaces: We used to sv: and to cl: blocks to write our server-side graph logic and our client-side React UI in the exact same .jac files, achieving a zero-API integration. Challenges we ran into The primary challenge was the "Cognitive Reset." Coming from a background of Next.js, React hooks, and REST APIs, we initially struggled to stop thinking in terms of "requests" and "state management."

In a traditional stack, syncing the backend AI state to the frontend UI involves complex WebSockets or polling loops. We had to unlearn this and trust Jac's to cl: and to sv: boundaries, learning how to let the language automatically sync the Graph Nodes with the UI state: Δ State_{Client} ≈ Δ Node_{Graph} Shifting from "Linear Logic" (fetching data) to "Spatial Logic" (walking a graph) took time, but once it clicked, our development speed skyrocketed.

Accomplishments that we're proud of We are incredibly proud of successfully migrating a fragmented, multi-tool architecture (Next.js + TypeScript + n8n workflows) into a single, elegant Jac codebase.

By adopting Jac, we eliminated 100% of our API boilerplate, removed brittle JSON-parsing logic, and replaced a complex web webhook system with native graph traversal. We built a visually stunning, highly reactive dashboard that is deeply rooted in cutting-edge AI language paradigms.

What we learned We learned that the future of AI applications isn't about better API wrappers; it's about AI-native languages. We discovered the massive advantages of Spatial Computing. By treating our application data as a physical space (a graph) to be explored by Walkers, rather than isolated endpoints, we can easily orchestrate complex multi-agent workflows that would be a nightmare to manage in traditional TypeScript.

What's next for GhostBoard The current GhostBoard is just the foundation. Next, we plan to:

Dynamic Sub-Agent Spawning: If an anomaly is highly technical, the CTO node will autonomously spawn temporary "DevOps" and "SecOps" sub-nodes to handle granular tasks before reporting back. Live External Ingestion: Building Walkers that constantly crawl external data feeds (market sentiment, live server logs) to update the graph organically before a crisis even hits. Multi-Modal Nodes: Expanding our MTP capabilities to process audio and visual crisis inputs directly into the Knowledge Graph.

Built With

• framer-motion
• n8n-automation
• next.js-15
• tailwind-css-4
• typescript
• vercel