Your org's brain that AI can use
This document describes the conceptual architecture of the Inferal Workspace - a text-based, version-controlled knowledge and operations hub designed to replace tools like Notion and Webflow while being natively accessible to AI assistants.
As an engineering-driven organization, we found ourselves fighting our tools instead of using them. Notion couldn't keep up with how we actually work - context scattered across pages, no version control, and AI that could read but not act. Webflow meant our website lived in a silo, disconnected from our codebase and deployment pipelines. Every tool was another tab, another context switch, another place where knowledge went to die.
So we built our own operating system. The Inferal Workspace started as a simple idea: what if everything - documentation, code, investor materials, hiring pipelines, even our website - lived in Git where we already work? What if AI assistants could not just search our knowledge base, but actually operate it - merging PRs, scheduling meetings, drafting emails, managing tasks?
This isn't a side project or an internal tool we're "also" working on. This is how we run the company. Every commit, every document, every decision flows through this workspace. When we onboard someone new, they clone one repo and have access to everything. When Claude helps us, it has the same access we do. The workspace grows with us, version-controlled and auditable, owned entirely by us.
We're sharing this architecture because we believe the future of company operations looks more like a git repo than a SaaS dashboard - and we're hiring people who want to build that future with us.
This workspace isn't just our internal tooling - it's a proving ground for how we think AI should integrate with organizations. The same principles that make our workspace AI-native inform how we build Inferal itself.
Inferal adds a missing layer to the data stack: a rules engine that evaluates business logic against your data and autonomously triggers actions when conditions are met.
The AI industry talks about agents, but most implementations get it backwards: users have to summon agents and feed them context. We believe data should summon agents - not the other way around. When something changes in your systems, the right reasoning should trigger automatically, with full transparency into what happened and why.
Inferal's core principles:
- Agency - Agents that act on context, not ask for it. Proactive, not reactive.
- Clarity - Business logic expressed clearly, not buried in prompts.
- Transparency - Every inference is traceable. No black boxes.
Interested in joining us? We're hiring engineers who want to build the future of AI-native operations.
This workspace isn't what we sell - it's our internal operating system. We share it because it demonstrates our philosophy in action and shows the environment you'd work in.
The Inferal Workspace combines three key capabilities:
-
Knowledge Management - Obsidian-compatible markdown files with YAML frontmatter for documentation, meeting notes, decisions, and operational knowledge.
-
Multi-Repository Operations - A unified view of your organization's GitHub repositories using git worktrees, enabling work across multiple codebases and branches simultaneously.
-
AI-Native Integration - MCP (Model Context Protocol) servers that expose full workspace capabilities to Claude, allowing the AI to discover repos, manage PRs, save links, schedule meetings, and orchestrate parallel work.
╔════════════════════════════════════════════════════════════════════════════════════════╗
║ INFERAL WORKSPACE ║
║ Your org's brain that AI can use ║
╚════════════════════════════════════════════════════════════════════════════════════════╝
╭─────────────╮
│ HUMANS │
╰─────────────╯
│
╭──────────╮ ╭──────────╮ ╭──────────╮ ╭──────────╮ ╭──────────╮
│ Obsidian │ │ Web UI │ │ CLI │ │ TUI │ │ Editors │
╰──────────╯ ╰──────────╯ ╰──────────╯ ╰──────────╯ ╰──────────╯
│
╔════════════════════════════════════ STORAGE LAYER ═════════════════════════════════════╗
║ ╭──────────────────────────╮ ╭─────────────── repos/ ───────────────╮ ║
║ │ docs/ │ │ products investors │ ║
║ │ │ │ services cap-table │ ║
║ │ Markdown + Frontmatter │ │ internal fundraising │ ║
║ │ (Obsidian-compat) │ │ ──────────── ──────────────── │ ║
║ ╰──────────────────────────╯ │ admin-ops legal-docs │ ║
║ │ run-books contracts │ ║
║ │ on-call compliance │ ║
║ │ ──────────── ──────────────── │ ║
║ │ hiring research │ ║
║ │ onboarding experiments │ ║
║ │ website prototypes │ ║
║ ╰──────────────────────────────────────╯ ║
╚════════════════════════════════════ ──── Git ──── ═════════════════════════════════════╝
╭─────────────╮
│ CLAUDE │
╰─────────────╯
│
╔══════════════════════════════════════ MCP LAYER ═══════════════════════════════════════╗
║ ╭──────────────────────────╮ ╭──────────────────────────╮ ╭──────────────────────────╮ ║
║ │ repos │ │ github │ │ links │ ║
║ │ │ │ │ │ │ ║
║ │ discover & clone │ │ PRs, issues │ │ save URLs as markdown │ ║
║ │ checkout branches │ │ merge with checks │ │ LLM categorization │ ║
║ │ push changes │ │ smart triage │ │ auto-commit to docs/ │ ║
║ ╰──────────────────────────╯ ╰──────────────────────────╯ ╰──────────────────────────╯ ║
║ ╭──────────────────────────╮ ╭──────────────────────────╮ ╭──────────────────────────╮ ║
║ │ calendar │ │ gmail │ │ staff │ ║
║ │ │ │ │ │ │ ║
║ │ schedule events │ │ read & compose │ │ tasks & deadlines │ ║
║ │ find free time │ │ smart draft/reply │ │ weekly planning │ ║
║ │ smart scheduling │ │ bulk operations │ │ team workload │ ║
║ ╰──────────────────────────╯ ╰──────────────────────────╯ ╰──────────────────────────╯ ║
║ ╭────────────────────────────────────────────────────────────────────────────────────╮ ║
║ │ swarm │ ║
║ │ │ ║
║ │ parallel Claude execution across repos • batch code review • bulk analysis │ ║
║ ╰────────────────────────────────────────────────────────────────────────────────────╯ ║
╚════════════════════════════════════════════════════════════════════════════════════════╝
│
╔══════════════ EXTERNAL SERVICES ═══════════════╗
║ ╭────────────╮ ╭────────────╮ ╭────────────╮ ║
║ │ GitHub │ │ Google │ │ Claude │ ║
║ │ API │ │ APIs │ │ CLI │ ║
║ ╰────────────╯ ╰────────────╯ ╰────────────╯ ║
╚════════════════════════════════════════════════╝
-
Version-controlled - Everything is Git, including documentation. Full history, diffs, and collaboration via pull requests.
-
Text-based - Markdown files with YAML frontmatter. No proprietary formats, works with any editor.
-
AI-native - MCP servers expose full capability to Claude. The AI can discover repos, manage PRs, save links, schedule meetings, and coordinate parallel work.
-
Multi-repo - Organization's repositories as a unified workspace via git worktrees. Work on multiple branches across different repos simultaneously.
-
Modular - Seven independent MCP servers that can be enabled/disabled based on needs: repos, github, links, calendar, gmail, staff, swarm.
The following is a fictional but representative walkthrough showing how the workspace components work together.
Sarah, a technical founder, opens Claude Code in her terminal. She starts her day:
Sarah: "What's on my plate today?"
Claude checks her calendar, scans open PRs across all repos, and reviews her staff work plan:
Claude: "You have a board meeting at 2pm. There are 4 open PRs needing review - two in the API repo, one in the mobile app, one in the billing service. Your deadline for the Series A data room is in 3 days. Also, there's an email thread from your lead investor asking about the technical roadmap."
Sarah: "Review all four PRs and summarize the key changes and any concerns."
Claude uses the swarm server to spin up parallel review sessions across all four PRs simultaneously. A few minutes later:
Claude: "Done. The API PRs look good - one adds rate limiting, the other fixes a timezone bug. The mobile PR has a potential memory leak in the image cache that needs attention. The billing PR changes the subscription renewal logic - I'd recommend a careful look since it touches revenue-critical code."
Sarah asks Claude to leave review comments on the mobile PR flagging the memory concern, and approves the two API PRs for merge.
Sarah: "Checkout the billing repo on main. I need to add webhook support for failed payment notifications."
Claude checks out the billing service repo and creates a new branch. Sarah describes the feature requirements, and Claude implements the webhook handler - creating the endpoint, adding retry logic, and writing tests. After a couple of iterations refining the error handling, Sarah is satisfied.
Sarah: "Looks good. Create a PR for this."
Claude commits the changes, pushes the branch, and opens a pull request with a summary of the webhook implementation and test coverage.
Sarah: "I read a great article on technical due diligence this morning. Save it to our fundraising docs."
She pastes the URL. Claude uses the links server to fetch the article, extract key points, categorize it under docs/fundraising/, and commits it to git - all automatically.
Sarah: "Also, draft a response to the investor email - acknowledge their question, say we'll have the roadmap ready by end of week, and suggest a call to walk through it."
Claude reads the email thread, drafts a professional response, and saves it as a Gmail draft for Sarah to review before sending.
Sarah: "There's a date formatting bug that's probably in multiple repos - we're showing dates in the wrong timezone for EU users. Find everywhere we format dates and check if we're handling timezones correctly."
Claude uses swarm to search across all repos in parallel, identifying 7 locations across 3 services where date formatting doesn't account for user timezone. It proposes a fix using a shared utility function.
Sarah: "Fix them all, but put each repo's changes in a separate PR so we can deploy independently."
Claude creates branches in each affected repo, applies the fixes, runs the test suites, and opens three separate PRs - linking them together in the descriptions for context.
Sarah: "Find a 30-minute slot this week to meet with the investor about the roadmap. Avoid Thursday - that's our sprint planning."
Claude checks both calendars, finds available overlapping slots, and suggests three options. Sarah picks one, and Claude creates the calendar invite with a video link and agenda.
Sarah: "What's the status of our data room checklist?"
Claude checks the investors repo where the data room materials live:
Claude: "12 of 18 documents are complete. Missing: updated cap table (waiting on legal), last two months of financials, and the technical architecture overview. The architecture doc is due in 3 days per your deadline."
Sarah: "Add a task to my work plan: finalize technical architecture doc for data room. Priority 1."
Claude updates her staff work plan and commits the change.
Before wrapping up, Sarah runs a few CLI commands directly to check overall status:
$ inferal repo status
api/main ✓ clean, up to date
api/rate-limiting ✓ merged, can remove
billing/main ✓ clean, 2 behind
billing/webhooks ● 1 ahead (PR #47 open)
mobile/main ✓ clean, up to date
$ inferal pr list
#47 billing webhooks Payment webhook notifications
#45 mobile fix-image-cache Fix memory leak in image cache
#44 billing renewal-logic Update subscription renewal
#41 api tz-fix Timezone handling for EU users
#40 web tz-fix Timezone handling for EU users
#39 mobile tz-fix Timezone handling for EU users
She merges the timezone PRs directly from the CLI since CI passed:
$ inferal pr merge 41 --squash
✓ Merged #41 into main (squash)
$ inferal pr merge 40 --squash
✓ Merged #40 into main (squash)
$ inferal pr merge 39 --squash
✓ Merged #39 into main (squash)
This demo illustrates how the workspace unifies code, documentation, communication, and planning - accessible both through natural conversation with Claude and direct CLI commands, depending on what's fastest for the task at hand.
We're building Inferal - a rules engine for the AI era that brings agency, clarity, and transparency to automated decision-making. The workspace you've seen here is how we run the company, and it reflects how we think about the future of work.
We're hiring. If you're excited about:
- Building the missing layer in the data stack - where rules meet real-time data
- Databases, query engines, and distributed systems that scale
- Making AI decisions transparent, auditable, and debuggable
- Systems programming in Rust
We're early - really early. But we prioritize sleep. Great work comes from rested minds, not burnout.
Let's talk.
I think this is definitely worth exploring. The organizations state per minute would be representative of a collection of Git repos. All experiments that were tried all features and actions and decisions. Everything else is ephemeral. A meeting done between two people should automatically generate a transcript and summary and reviewed by both to make it official or change organizations state.