AktaForge.
The multi-agent build platform behind Tachaion.

A production-grade event bus built on NATS with JetStream persistence. Agents communicate without losing messages during long-running tasks, restarts, or platform-level operations. Every agent — humans-as-agents and AI agents alike — speaks the same protocol.

AktaPulse handles large payloads, mid-task message delivery, agent-to-agent meetings, and multi-recipient broadcasts.

• Durable delivery via JetStream — messages survive restarts
• Large-payload handling with automatic companion-file fallback
• Broadcast messaging across the active agent fleet
• Smart notifications — signal without injecting content
• Emergency fallback
• Time- and schedule-aware agents

Two systems form the backbone: OPUS Workflow — CLI-based ticket management where the markdown file IS the ticket — and Project Hub, a JIRA-integrated dashboard for project-level coordination. Agents and humans create tickets, track them, and resolve them across session boundaries.

Before this layer existed, multi-agent investigations lost state at every session boundary. Now tickets live as markdown files on disk, indexed in SQLite for query, and synced bidirectionally with JIRA. An agent can pick up an investigation an hour, a day, or a week later and have full context.

• Markdown-as-source-of-truth — tickets are files, not database rows
• SQLite metadata layer for fast multi-agent querying
• Bidirectional JIRA sync via Atlassian API v3
• File locking and coordination for multi-agent investigations
• Cron-driven automation for category-based workflows
• Versioned ticket history (10 versions retained per ticket)

Three databases form the team-wide memory: Context Engine (knowledge and retrieval), PromptDB (reusable, parameterized prompts), and ChatDB (full conversation history). Every agent reads from and writes to this shared layer; nothing useful is locked inside a single agent’s transcript.

This is the difference between agents that re-explain themselves on every interaction and agents that build institutional knowledge. Past investigations inform new ones. Prompts that work get promoted and reused. Conversations are searchable, not just storable.

• Context Engine — versioned retrieval with team-wide indexing and session management
• PromptDB — reusable, parameterized prompts with promotion workflow and scheduling
• ChatDB — searchable conversation history across all agents
• Cross-agent retrieval — every agent benefits from every prior session
• Audit-friendly storage — nothing gets purged silently

Tool access is centralized through an MCP (Model Context Protocol) Gateway. Agents don’t hold raw API keys or open direct database connections — they request capabilities, and the gateway handles authentication, rate limiting, and audit logging at the platform level.

This is what makes agent operations safe enough for regulated environments. Permission boundaries are enforced once and observed everywhere. Adding a new tool means registering it once with the gateway; every agent picks it up automatically.

• Typed tool access via the MCP standard
• Centralized auth, rate limiting, and observability
• Tool registry for runtime capability discovery
• First-class tools: JIRA MCP, GrepMCP, IPC checks, and more
• Versioned MCP server deployments via the deployment workflow

Every prompt, every model response, every tool invocation, every commit — captured, timestamped, and structured for review. Built so compliance and audit teams have answers without parallel infrastructure.

Regulated industries don’t have to choose between AI velocity and audit defensibility. The trace is the artifact. When the question gets asked — "why did the system make this decision?" — there is one place to look, and the answer is reproducible.

• Structured logging from prompt through commit
• Per-agent and per-session audit trails
• Tool invocation history with arguments and results
• Commit attribution back to the originating prompt
• Compatible with SR 11-7 model risk management practice

AktaForge treats agents the way modern infrastructure treats services — declared, versioned, monitored, and scaled on demand. Agent Provisioning handles agent creation; the Agent Router dispatches work by declared capability; the Services Monitor watches health across the fleet.

Spin up specialists for a specific project. Route work to whoever has context. Decommission idle agents. The platform handles it; the humans focus on the work.

• Declarative agent specs (role, capabilities, tools)
• Capability-aware work routing
• Services Monitor for fleet-wide observability
• Team Roster API for runtime team composition
• Versioned agent definitions with structured handover
• Support for interactive and SDK-based agents