Medhara
The memory and governance core behind PlantoOS. Persistent memory, capability control, deterministic lineage — the kernel that makes agent systems governable.
Agents scale decisions. Medhara scales control.
- ●Persistent memory across time — agents recall, not re-gather
- ●Capability governance — who and what can access, act, and modify
- ●Deterministic execution lineage — every path reproducible
- ●Compliance-ready auditability — audit artifacts as a side-effect of execution
↓ 20–35%
Redundant retrieval / token spend
↓ 30–45%
Debugging time with replayable lineage
↑ 15–30%
Multi-step task success rate
Indicative ranges from internal benchmarks and early deployments; results vary by workflow.
Medhara Core = 4 primitives
The building blocks that make agent systems governable, persistent, and auditable.
Memory Objects
Structured, versioned, and linked. Every memory entry carries type, scope, TTL, and provenance metadata from creation through every read.
Policies & Access
Capability-based access control evaluated at every boundary. Six-layer policy stack from org to action level, deny-by-default.
Lineage
Every decision is traceable. Full DAG from trigger to terminal state, queryable via API, exportable in standard audit formats.
Crystallization
Raw observations → structured facts → distilled intuitions. Medhara progressively compresses experience into actionable knowledge.
From activity to institutional memory
Medhara progressively transforms raw observations into structured, actionable knowledge.
Memory Crystallization
How Medhara transforms raw activity into institutional memory.
Raw Events
Logs, conversations, actions.
Observations
Signals and detected patterns.
Structured Knowledge
Entities, links, and relationships.
Operational Memory
Reusable context across workflows.
Institutional Intuition
Systems improve decisions over time.
Medhara transforms activity into structured memory.
Every action has lineage
Full traceability from trigger to terminal state — every decision reconstructable.
Decision Lineage
Every agent action is fully reconstructable.
User initiates action
Intent parsed, plan formed
API invoked with parameters
External system mutated
Result verified and recorded
Every action should be reconstructable.
How Medhara powers PlantoOS
Medhara sits at the kernel level — between agents and enterprise systems — enforcing governance and persisting memory.
Applications
Your products and workflows
Agents
LLM-powered autonomous units
PlantoOS Runtime
OS shell + execution engine
Medhara Core
Memory + Governance kernel
Enterprise Systems
Databases, APIs, infrastructure
Provenance
Boundaries
Replay
Forgetting / Retention controls
What changes when you add Medhara
A side-by-side view of agent systems with and without governed memory and lineage.
Capability
Without Medhara
With Medhara
Memory
Stateless per session. Agents re-gather context every time.
Persistent, typed, versioned. Memory survives across sessions with provenance.
Tool Access
Ambient authority. Agents can call any available tool.
Capability-bounded. Every tool call evaluated against policy stack.
Auditability
Manual log correlation. Reconstructing decisions requires custom work.
Full lineage DAG. Every action traceable from trigger to output.
Debuggability
Black box. Reproduction requires re-running the full chain.
Deterministic replay from any checkpoint with identical outputs.
Compliance
Post-hoc artifact assembly. Evidence gathered after the audit request.
Continuous audit artifacts. Compliance data generated as a side-effect of execution.
Where we are headed
Medhara's roadmap — from memory foundation to ecosystem readiness.
Phase 1
Capture & Recall
Memory foundation: typed writes, provenance tracking, ranked retrieval, TTL-based lifecycle management.
Agents retain and recall structured context across sessions
Phase 2
Governance & Policies
Capability enforcement: six-layer policy stack, deny-by-default evaluation, RBAC-like access control at every boundary.
Every agent action evaluated against declarative policy rules
Phase 3
Runtime Determinism
Replay and lineage: deterministic execution paths, checkpoint-based rollback, full action DAGs for root-cause analysis.
Any agent run reproducible from any checkpoint
Phase 4
OS Marketplace Readiness
Extensible apps and connectors: third-party integrations, app marketplace, governed plugin boundaries.
Ecosystem of governed, composable agent capabilities
Frequently asked questions
No. Medhara is a governed memory layer, not a storage engine. It manages typed, versioned memory objects with provenance, access control, and lifecycle policies. Vectors may be used internally for retrieval ranking, but Medhara's value is in the governance, lineage, and crystallization layers above raw storage.
Yes. Medhara provides SDK wrappers for Python and TypeScript. You initialize a client, connect it to your agent loop, and use typed memory operations. The SDK handles provenance tracking, policy evaluation, and lineage capture transparently.
Our intended model is hybrid: customers can choose between Medhara-hosted storage or customer-controlled storage (your own infrastructure). In both cases, encryption at rest and in transit is standard, and access is governed by the same policy stack.
Observability tools watch what happened. Medhara governs what happens. It combines memory persistence, capability enforcement, and lineage tracking into a single kernel — not just logging and dashboards. PlantoOS is the OS experience layer on top.