The AIN Company Brain Primitive: continuously compiles Slack, Jira, and Gmail into an executable, conflict-resolved operational state for AI agents.
The ain-state-compiler operates 100% offline at the source level, parsing and aggregating enterprise communication and issue-tracking streams to produce internally consistent state representations. It prevents AI agents from executing against stale, fragmented, or conflicting corporate knowledge.
With the release of v1.0.0, ain-state-compiler graduates to an enterprise-grade agentic framework by incorporating industry-standard paradigms:
- LangGraph-style Explicit Conflict Reducers and Human-in-the-Loop interventions.
- LlamaIndex-style Structured Data Extraction using typed schemas.
- MemGPT/Letta-style Core Memory Editing Tools for long-term agent state persistence.
pip install ain-state-compilerEnsure that you have Python 3.9+ installed. For the MCP and Ollama integrations, you must have the respective local dependencies running.
ain-state-compiler is built to run entirely inside your isolated network. To guarantee supply-chain integrity, we explicitly adhere to the highest open-source security standards:
- Trusted Publishing (OIDC): This package is built and signed directly via GitHub Actions using OpenID Connect (OIDC). There are no static passwords, ensuring 100% cryptographic source-to-binary alignment on PyPI.
- Zero External Dependencies: We deliberately shun heavy 3rd-party dependencies like
pydantic. The entire core is built using Python standard libraries (e.g.dataclasses), eliminating deeply nested supply-chain vectors and dependency confusion risks. - 100% Offline by Default: The entire compilation engine processes local data. If LLM evaluation is enabled via
AutoDebugger, it binds to local Ollama instances natively—no telemetry, no cloud webhooks, no OpenAI API keys needed.
We provide multiple interfaces depending on your exact integration needs.
Target Audience: Claude Desktop, Cursor, Codex users.
The ain-state-compiler natively exposes the Model Context Protocol via FastMCP. Instead of copying and pasting internal slack logs into your agent window, just mount the MCP server!
How to Start the Server:
python -m ain_state_compiler.mcp_serverClaude Desktop Configuration (claude_desktop_config.json):
{
"mcpServers": {
"ain-brain": {
"command": "python",
"args": ["-m", "ain_state_compiler.mcp_server"]
}
}
}Available Tools:
search_ain_context(query_text: str, limit: int): BM25 Semantic Search for unstructured questions (e.g. "Why did the analytics migration fail?").search_ain_by_tag(tag: str, limit: int): Exact O(1) matching for specific entities (e.g. "acme_billing").edit_core_memory_replace(key: str, value: str): MemGPT-style tool to rewrite agent instructions and persona.edit_core_memory_append(key: str, value: str): MemGPT-style tool to maintain long-term internal monologue over weeks or months.
Target Audience: Local LLM Developers.
If you are running ollama locally, you can route queries securely through native tool-calling pipelines.
Usage:
from ain_state_compiler.ollama_plugin import run_query_with_tools
# The plugin will automatically invoke `search_context` tools behind the scenes!
answer = run_query_with_tools("What did Sara say about the latency spike?", model="gemma3:1b")
print(answer)Target Audience: DevOps & CI/CD Pipelines.
The CLI allows you to trigger syncing, ingestion, and offline queries.
Initialize the Internal Database:
ain-brain init-dbIngest from Sources (LlamaIndex-style Typed Extraction): (Pulls from your configured Jira, Slack, and Email APIs, mapping them directly into Pydantic-style Python dataclasses).
ain-brain ingestSync with Human-in-the-Loop Reducers: (Runs a one-shot compilation and pauses if LangGraph-style heuristic reducers cannot automatically resolve a conflicting state).
ain-brain sync --human-in-the-loopRun a Query: (This invokes the Ollama tool-calling pipeline if running, or falls back to deterministic resolvers).
ain-brain query "analytics latency"Target Audience: Backend Engineers building custom agent frameworks.
from ain_state_compiler.compiler import StateCompiler
from ain_state_compiler.retrieval import search_context
# 1. Compile state and detect conflicts
compiler = StateCompiler(project_dir="/path/to/project")
summary = compiler.compile()
print(f"Detected {summary['detected_conflicts']} active state conflicts.")
# 2. Programmatically Retrieve specific snippets
results = search_context("analytics_v2", limit=3, project_dir="/path/to/project")
for snippet in results:
print(snippet)Internalizes the spirit of the "lazy senior dev" reductionist mindset directly into the core architecture:
- LazyStateFilter: A strict deterministic "No-Op" filter that drops incoming data if it does not meaningfully mutate the operational state.
- StateReuseEngine: Scans a historical cache of previously resolved conflicts. If a highly similar transformation exists, the compiler clones and adapts rather than generating from scratch.
- StateCompilerEngine: Enforces rigid bounds (
max_tokens, length limits) on LLM compilation passes, aborting cleanly to naive primitives if structural code bloat occurs.
- ConflictDetector: Runs rule-based, deterministic logic to spot discrepancies before invoking generation.
- ReducerRegistry: Define custom Python functions to merge conflicts programmatically. If no reducer matches, falls back to an optional
--human-in-the-loopprompt. - TokenOptimizer: Compresses verbose JSON state outputs into highly dense YAML representations, minimizing token footprint.
- DataLoaders: Unstructured inputs are instantly mapped into structured
DocumentNodeschemas (e.g.SlackMessageNode,JiraIssueNode).
- CoreMemory: Provides explicit CRUD tools allowing the agent LLM to self-edit its own prompt context indefinitely, surviving reboots and cache clears.
- LangGraph Reducers: Introduced
ReducerRegistryto programmatically resolve state merge conflicts. - Human in the Loop: Added
--human-in-the-looptoain-brain syncCLI command. - LlamaIndex Schemas: Introduced
ain_state_compiler.ingest.loaders.DataLoaderto enforce Pydantic-like dataclass typing on ingest streams. - Letta/MemGPT Core Memory: Introduced
ain_state_compiler.core_memory.CoreMemoryand exposed explicitedit_core_memoryself-editing tools to MCP and Ollama pipelines.
- Extensive Documentation: Added detailed execution guides for MCP Servers, Ollama Tooling, and CLI usage directly to the PyPI page. Fixed Windows emoji encoding bugs during packaging.
- LLM-Native Retrieval Revamp: Shifted away from raw Markdown context dumps to token-efficient Retrieval-Augmented Generation (RAG).
- FTS5 Fast Search: Extracted tight, context-rich snippets (truncated to scale) instead of unbounded document loads.
- MCP Server: Added
mcp_server.pyusingFastMCPexposingsearch_ain_contextandsearch_ain_by_tagto tools like Claude Desktop and Codex. - Native Ollama Tools: Added
ollama_plugin.pyto route local queries securely through tool-calling pipelines.
- Rebranding: Updated GitHub URLs and package author metadata to That-Tech-Geek.
- Ponytail Architecture: Introduced programmatic gatekeepers.
- State Minimization: Implemented deterministic noise filtering.