Your AI forgets you exist. Ours remembers for 20 years.
Eight open-source systems. Eight file formats. Forever yours.
.amem · .avis · .acb · .aid · .atime · .acon
.acomm · .aplan
> curl -fsSL https://agentralabs.tech/install/memory | bashDefault desktop profile (backward-compatible): installs binaries and auto-merges MCP config for common clients when detected (Claude, Cursor, VS Code, Codex, Windsurf).
> curl -fsSL https://agentralabs.tech/install/memory/desktop | bashExplicit desktop profile with MCP auto-merge for common desktop clients.
> curl -fsSL https://agentralabs.tech/install/memory/terminal | bashTerminal profile: installs binaries only, no desktop config writes.
> curl -fsSL https://agentralabs.tech/install/memory/server | bashServer profile: installs binaries only for remote hosts and service-style environments. Then run agentra server preflight.
> pip install amem-installer && amem-install install --autoAuto-connects memory to compatible MCP clients.
Local mode keeps .amem, .avis, .acb, .aid, .atime, .acon, .acomm, and .aplan as portable files under your control. After install, run: agentra status --session and agentra doctor.
Twenty years from now, you'll open a new AI tool. You'll drag in a folder. Your agent will know you.
20 years of your agent's cognitive history. Portable. User-owned. Works offline forever.
Load these files into ANY model — Claude, GPT, Llama, local. The files make any model YOUR agent.
20 years of memory, vision, code, identity, time, governance, communication, and planning. Fits on your phone. Backs up like photos.
The model is commodity. The files are value.
These aren't feature lists. These are before-and-after scenarios showing how agents behave with and without the Agentra stack.
"Why did you recommend Python last week?"
"I don't have access to previous conversations."
"I recommended Python because: (1) your team has no Rust experience [fact from session 12], (2) deadline was two weeks [fact from session 12], (3) existing codebase is Python [fact from session 8]. Three facts. One chain."
"The checkout button stopped working yesterday"
"I can't see your UI. Can you describe what's happening?"
"Comparing captures from Tuesday vs Wednesday: the button moved 12px left, z-index dropped to 10, and a new modal overlay now covers it. CSS change in commit af7c2 caused this. Quality score: 0.94."
"Refactor the payment flow for multiple currencies"
Agent greps for "payment." Finds 150 files. Edits some. Hopes tests catch what it missed.
"Before I write code: 23 callers need updates. audit_log has 91% co-change coupling with no test coverage. The Stripe wrapper assumes USD at the FFI layer. Stability score: 0.41. Want a migration plan first?"
"Which agent authorized that production deployment?"
No agent identity exists. API keys are shared. Logs show a token was used but not which agent acted or why.
"Agent deploy-bot-7 (anchor a3f8...c2) signed receipt #1847 at 14:32:07 UTC. Trust grant from ops-lead (anchor 91b2...e4) scoped to deploy:staging,deploy:prod with 24h TTL. Full receipt chain: 3 hops, all signatures valid."
"When can we schedule the database migration without conflicts?"
Agent has no concept of time. It suggests "this weekend" without checking existing schedules, deadlines, or team availability.
"Analyzing temporal state: 3 hard deadlines within 7 days, 2 recurring schedules overlap Saturday. Available 4-hour window: Sunday 02:00-06:00 UTC. PERT estimate for migration: optimistic 2h, expected 3.5h, pessimistic 6h. Temporal debt on deferred schema changes: 1.4x compounding. Recommend the Sunday window with rollback sequence pre-staged."
"Can this agent deploy to production without approval?"
No governance layer exists. The agent has the API key, so it deploys. No policy check, no risk limit, no approval workflow. Hope nothing breaks.
"Policy check: deploy:production requires approval from ops-lead. Risk limit: 3/5 daily deployments used (budget limit). Obligation: post-deploy monitoring required within 30 minutes. Auto-creating approval request #47 with smart escalation to on-call approver. Estimated approval likelihood: 87% based on prior patterns."
"How do I coordinate three agents working on the same feature?"
Agents write to shared text files. Messages are unstructured. No ordering guarantee. No subscriptions. One agent overwrites another's output.
"Created channel #feature-auth with 3 subscribers. Task message sent to planner agent, acknowledged in 40ms. Worker agent subscribed to task channel, received assignment with typed payload. Status broadcast sent to all: 2/3 subtasks complete. Full message history searchable in .acomm artifact."
"What should the agent prioritize when three goals conflict?"
Agent has no goal structure. It picks the first task it sees, ignores trade-offs, and hopes the user corrects it later. No commitments tracked, no decisions recorded.
"Analyzing goal graph: 3 active goals, 2 share a dependency. Goal #1 (ship auth) has hard deadline in 48h, priority 0.95. Goal #2 (refactor DB) blocks Goal #3 (add caching). Decision recorded: defer Goal #3, commit to Goal #1 with 2-day sprint, revisit Goal #2 after deadline. Full decision chain preserved in .aplan artifact."
Real benchmarks. Real hardware. Apple Silicon, Criterion.rs, release builds.
These systems are built for one outcome: less repeated work, fewer blind releases, and faster incident resolution. The links below show real with-vs-without simulations with commands, tradeoffs, and practical operating limits.
Long-horizon memory that stays usable
With budget policy and rollup, teams can target multi-year continuity instead of losing context every quarter.
Release risk triage before merge
Instead of manual guessing, teams get ranked risk and explicit reasons for where to harden first.
Visual incidents become queryable
When logs are not enough, teams can capture, query, OCR, diff, and link visual state through MCP workflows.
Every agent action gets a signed receipt
API keys are shared secrets with no audit trail. AgenticIdentity gives every agent a cryptographic anchor so every action is signed, scoped, and verifiable.
Deadlines and schedules become queryable state
Agents have no clock. They suggest "this weekend" without checking calendars, conflicts, or compounding debt. AgenticTime gives every agent temporal reasoning so scheduling decisions are grounded in real constraints.
Policy enforcement becomes machine-readable
Agents act without guardrails. They approve actions no human reviewed, exceed budgets no one set, and skip steps no policy enforced. AgenticContract gives every agent governance so decisions are bounded, auditable, and self-healing.
Agent coordination becomes structured communication
Agents pass unstructured text hoping the other reads it. No channels, no ordering, no subscriptions. AgenticComm gives agents structured communication with named channels, typed messages, pub/sub, and full-text search.
Strategic reasoning becomes persistent state
Agents have no memory of their goals. They restart every session without knowing what they committed to, what decisions they made, or what strategy they chose. AgenticPlanning gives agents persistent goals, decisions, commitments, and strategic reasoning with dream simulations.
We collaborate with research labs, enterprise engineering teams, and infrastructure sponsors building reliable long-lived agent systems. Our focus is continuity, governed execution, and audit-ready operations.
We build the substrate where AI agents stop operating page by page. AgenticVision maps the web into queryable graphs, AgenticMemory preserves reasoning continuity, AgenticCodebase compiles repositories into semantic intelligence surfaces, AgenticIdentity provides cryptographic trust, AgenticTime adds temporal reasoning with deadlines, schedules, and decay models, AgenticContract enforces policy governance with risk limits, approval workflows, and self-healing contracts, AgenticComm provides channels, pub/sub, and message coordination across long-running agent sessions, and AgenticPlanning manages persistent goals, decisions, commitments, and strategic reasoning with dream simulations and multi-agent federation.
The stack is MCP-native, artifact-portable, and designed for long-running production workflows: browserless mapping, direct action execution, typed compilation, collective deltas, and temporal memory across sessions.
AgenticMemory — reasoning that persists. AgenticVision — visual state that's queryable. AgenticCodebase — code understanding with prediction. AgenticIdentity — cryptographic proof of agent action. AgenticTime — temporal reasoning with deadlines. AgenticContract — policy governance for agents. AgenticComm — structured channels and message routing for cross-agent coordination. AgenticPlanning — persistent goals, decisions, and commitments. All open source. All shipped.
Ask any AI "why did you recommend that?" and you'll get a made-up answer. Not because it's dishonest — the reasoning evaporated when the context window closed. AgenticMemory stores reasoning chains so "why?" has a real answer.
Every decision has CAUSED_BY edges connecting it to the facts that led to it. The chain is traversable. Corrections link to what they fixed. Truth evolves across sessions in portable .amem files.
CAUSED_BY edges: Walk backwards through reasoning. Every recommendation traces to the facts that drove it.
SUPERSEDES chains: Corrections link to what they replaced. Old beliefs stay visible. Truth has a history.
16 query types: Traversal, temporal diffs, causal analysis, semantic search, and belief revision on graph structure.
6 event types: Facts, decisions, inferences, corrections, skills, and episodes. Each typed, timestamped, and linked.
"The button broke yesterday." Your AI can't see yesterday. It can't see the button. It asks you to describe everything, then guesses. AgenticVision captures visual state as queryable evidence.
When the button breaks, the agent diffs Tuesday vs Wednesday, finds the CSS change, traces it to a commit, and links the evidence to memory. Screenshots become queryable in portable .avis files.
vision_capture: Structured screenshots with CLIP embedding, metadata, quality scoring, and optional OCR extraction.
vision_diff: Pixel-level comparison between two states. What changed, where, and by how much.
vision_similar: Find matching past states by visual similarity. Cosine distance on 512-dim CLIP embeddings.
Memory bridge: Link screenshots to cognitive graph nodes. Visual evidence connects to reasoning chains.
"Refactor this function." Your AI cheerfully edits the code. It has no idea that 47 other functions call this one. It doesn't know the test suite catches 12 failures but misses 35. AgenticCodebase fixes that.
Before writing one character, the agent walks callers, tests, and hidden couplings. Compile any repo into a portable .acb graph with impact analysis, stability scoring, and breakage prediction.
IMPACT edges: Trace what depends on what you're changing. Callers, tests, and downstream paths exposed before edits land.
COUPLES_WITH: Hidden dependencies from git co-change patterns. The connections your linter can't see.
PROPHECY: Predict failures from stability analysis and temporal drift. Stage migrations safely.
14.3 µs lookup: Symbol lookup in microseconds, index access in nanoseconds. Structure at the speed of thought.
"Who did this?" Your agent deployed code, called APIs, and approved a transaction. But there is no cryptographic proof. No signed receipt. No scoped trust. AgenticIdentity anchors every agent action to a verifiable identity.
Every agent gets an Ed25519 key pair as its identity anchor. Every action produces a signed receipt. Trust between agents is granted, scoped, delegated, and revoked through signed trust grants. Everything is portable in .aid files.
Identity anchors: Ed25519 key pairs that uniquely identify each agent. Deterministic, portable, and verifiable by anyone with the public key.
Action receipts: Signed records of every operation. Tamper-evident, timestamped, and chainable into complete audit trails.
Trust grants: Scoped, time-limited delegation tokens. Grant deploy:staging but not deploy:prod. Revoke instantly.
Microsecond signing: Ed25519 operations complete in microseconds. Zero latency overhead for production agent workflows.
"When should we migrate?" Your agent has no clock, no calendar, no sense of deadlines or decay. It suggests "this weekend" without checking schedules, conflicts, or compounding debt. AgenticTime gives agents temporal reasoning.
Every temporal entity — deadlines, schedules, sequences, durations, decay models — is stored, queried, and reasoned over. PERT estimation, conflict detection, and timeline fork analysis in portable .atime files.
5 entity types: Duration, Deadline, Schedule, Sequence, and Decay. Each typed, timestamped, and linked to temporal chains.
PERT estimation: Three-point estimates (optimistic, expected, pessimistic) for realistic scheduling under uncertainty.
Temporal debt: Compounding cost models for deferred work. See how delay cascades before it compounds.
Timeline forks: Branch temporal state to compare outcomes before committing. What-if analysis for scheduling.
"Is this agent allowed to do that?" Your agent deploys code, approves requests, and allocates resources — with no policies, no risk limits, and no approval workflows. AgenticContract gives agents governance.
Every agent action is checked against policies, risk limits, and approval workflows. Obligations track what must be done. Violations are detected before they compound. All governance state lives in portable .acon files.
Policy engine: Allow, deny, or require approval for any action. Scoped to global, session, or individual agents with tag-based matching.
Risk limits: Rate, threshold, budget, and count limits that prevent agents from exceeding safe boundaries.
Approval workflows: Multi-party approval chains with smart escalation routing. Request, decide, and audit every controlled action.
Self-healing contracts: Contracts that automatically adapt policies when violations are detected. Governance that learns from incidents.
"How do agents coordinate?" They pass text files around hoping the other reads them. No channels, no ordering, no subscriptions. AgenticComm gives agents structured communication with named channels, typed messages, and searchable history.
Every message flows through named channels with typed payloads, ordering guarantees, and acknowledgments. Agents subscribe to topics, broadcast status, and search history. All coordination lives in portable .acomm files.
Channel topology: Direct, group, broadcast, and pub/sub channels in one runtime. Each channel is named, typed, and searchable.
Typed messages: Commands, queries, responses, notifications, and acknowledgments. Every message has a type, sender, timestamp, and payload.
Subscriptions: Pattern-based subscriptions with delivery guarantees. Subscribe to channels, topics, or message types.
Full-text search: Search across all channels and messages. Filter by sender, type, channel, or content. Results ranked by relevance.
"What should we do next?" Your agent picks the most obvious task. It has no goal graph, no decision history, no commitment tracking. It can't tell you why it chose this path or what it traded off. AgenticPlanning gives agents strategic reasoning.
Every goal lives in a hierarchical graph with priorities, dependencies, and conflict resolution. Decisions record rationale, alternatives, and outcomes. Commitments track deadlines and stakeholders. All strategy lives in portable .aplan files.
Goal graph: Hierarchical goals with priorities, dependencies, blockers, and lifecycle states. The agent always knows what matters most.
Decision records: Every strategic choice captured with rationale, alternatives considered, and outcome. Trace why any path was chosen.
Commitment tracking: Promises with owners, deadlines, deliverables, and stakeholders. Progress measured against explicit criteria.
Federation: Multi-agent coordination with shared goals, sync state, and consensus. Teams of agents plan together.
Channel routing
Real-time feedback, support requests, integration debugging, and community coordination.
Join @agentralabsShowcase highlights, launch updates, and public signal from builders.
Follow @agentralabFormal contact for integrations, support escalation, and collaboration requests.
contact@agentralabs.tech