# Plexara

> A fully managed MCP data platform from Deasil Works. Plexara connects AI agents to enterprise data through one governed Model Context Protocol endpoint, and every answer arrives with the business context, institutional knowledge, and access rules the agent needs to be right.

Plexara is operated by Deasil Works, Inc. Each customer gets a dedicated installation that Deasil provisions, hosts, upgrades, and monitors; the customer connects an AI agent over MCP and works in the Plexara portal. The platform provides federated SQL across warehouses and databases (Trino), catalog metadata and governance (DataHub), object storage, REST API and MCP gateways, persona-based access control, audit logging, a memory and knowledge layer that promotes what people teach the agent into shared documentation, spreadsheets registered as queryable tables, and automations that run agent-written scripts on demand or on a schedule.

The full text of every page listed here is available in one file at https://plexara.io/llms-full.txt.

## Company

- [Plexara](https://plexara.io/): Plexara transforms your enterprise data into a domain-expert training manual for AI through governed, semantically rich integration.
- [Our Thesis](https://plexara.io/approach/): The thesis behind Plexara: standards over products, composable architecture, and progressive implementation that captures tribal knowledge.
- [Services](https://plexara.io/services/): Deasil Works provides custom data platforms, Plexara implementation, and managed services backed by 25+ years of enterprise data infrastructure experience.
- [Contact](https://plexara.io/contact/): Start a conversation about your data landscape. Tell us what you are trying to achieve with AI and we will respond within one business day.
- [Architecture](https://plexara.io/architecture/): Plexara's 8-layer middleware pipeline composes Trino, DataHub, and S3 through provider abstractions into a single governed MCP server with fail-closed security.
- [Locations](https://plexara.io/locations/): Six data center facilities across the United States. Over 30 years of managing real infrastructure, from bare-metal hardware to custom Kubernetes clusters.
- [History](https://plexara.io/history/): Plexara began in 2024 as Methodology, an internal Deasil Works project for text-to-SQL. The timeline from sentence embeddings and StarCoder to MCP and the platform Plexara is today.
- [Team](https://plexara.io/team/): Plexara is a product of Deasil Works, Inc. Meet the engineers behind it: founders Jeff Masud and Craig Johnston and the core team that has built and operated enterprise systems together for over 25 years.
- [Developers](https://plexara.io/developers/): Build on Plexara. Complete REST API for assets, collections, knowledge capture, memory, personas, prompts, audit, governance, and tool execution.
- [Security](https://plexara.io/security/): How Plexara's managed architecture addresses MCP vulnerabilities disclosed in recent security research, including the April 2026 OX Security findings.
- [Trust Center](https://plexara.io/trust/): Plexara as a vendor: single-tenant deployment model, encryption, access control, incident response, subprocessors, DPA availability, and compliance posture.
- [Vulnerability Disclosure Policy](https://plexara.io/vulnerability-disclosure/): How to report a security vulnerability in Plexara, what is in scope, and what to expect: acknowledgment within two business days and coordinated disclosure.

## Product

- [Product](https://plexara.io/product/): Plexara unifies query execution, semantic metadata, and object storage into a single governed MCP server with semantic enrichment and enterprise governance.
- [Semantic Search and Enrichment](https://plexara.io/product/semantic-enrichment/): Bidirectional enrichment augments every tool response with business context from complementary services. One call replaces four.
- [Knowledge Capture & Application](https://plexara.io/product/knowledge-application/): Every conversation improves your data catalog. User corrections, agent discoveries, and enrichment gaps flow through admin review into documentation.
- [Catalog Governance](https://plexara.io/product/catalog/): Curate the tag vocabulary, the domains, and the business glossary in the same portal your agent works through, under the same access rules.
- [Memory](https://plexara.io/product/memory/): Persistent memory across sessions, structured into five dimensions. Multi-strategy recall via entity lookup, semantic search, and lineage graph traversal.
- [Governance](https://plexara.io/product/governance/): Governance enforced at the point of execution. Fail-closed security, persona-based tool filtering, comprehensive audit logging, and operational safeguards.
- [Portal Tour](https://plexara.io/product/portal/): A guided tour of the Plexara portal: assets and their viewers, collections, a versioned prompt library, resources, feedback, the knowledge pipeline, catalog governance, and the knowledge graph.
- [Portal Administration](https://plexara.io/product/portal/admin/): The administrative half of the Plexara portal: the activity dashboard, audit events, fleet and index health, personas, tools, connections, API catalogs, keys, and the user directory.
- [Email Notifications](https://plexara.io/product/notifications/): Shares, comments, and mentions reach people in their inbox, on terms each person sets. Your admins can route outbound mail through your own provider.
- [Integrations](https://plexara.io/product/integrations/): Trino federation across 40+ connectors, DataHub catalog operations, S3 object storage, and MCP client compatibility through a single governed endpoint.
- [API Gateway](https://plexara.io/product/api-gateway/): Connect any REST or HTTP API to Plexara and let your AI assistant search and call it directly. One secure connection that handles sign-in, limits access by role, and logs every call.
- [MCP Gateway](https://plexara.io/product/mcp-gateway/): Connect any MCP server to Plexara and its tools join your assistant's toolkit under one endpoint: persona rules, server-side credentials, cross-enrichment with your warehouse, and a single audit log.
- [Spreadsheets as Tables](https://plexara.io/product/spreadsheets/): Upload a CSV to Plexara, register it as a table in one step, and your AI assistant joins it against the warehouse with SQL. Nothing is copied, staleness is flagged, and every registration is audited.
- [Automations](https://plexara.io/product/automations/): Your agent writes a script once; Plexara runs it on demand or on a schedule. Reports, exports, and dashboard refreshes keep arriving with no agent in the loop, no token spend, and every run recorded.
- [Changelog](https://plexara.io/product/changelog/): A weekly, plain-language record of new capabilities and improvements in the fully managed Plexara platform. Newest first.

## Use cases

- [Use Cases](https://plexara.io/use-cases/): Real work from two Deasil Works engagements: capacity models from live telemetry, release-day verification, fraud scoring, win-back audiences, and root-cause analysis across systems, all through one governed connection.
- [The Whole Year Comes Down to One Week](https://plexara.io/use-cases/retail/): A retail client story from Deasil Works: capacity models from live telemetry, release-day verification, fraud scoring, and a day of analyst work done in twenty minutes.
- [Teaching the Agent Everything We Know](https://plexara.io/use-cases/public-media/): A public broadcaster story from Deasil Works: a knowledge loop that turns corrections into shared truth, audiences built in an afternoon, and a client that inherited the workflow.

## Research

- [Plexara Research](https://plexara.io/benchmark/): Controlled, open benchmarks of the platform: published raw data, fully reproducible source code, and DOI-archived reports anyone can run and any researcher can build on.
- [The Accuracy Study](https://plexara.io/benchmark/accuracy/): The semantic layer lifted accuracy on business-rule questions from 42.7% to 98.7%, a +56-point gain over bare data tools, and a fresh install with an empty knowledge layer visibly learned each fact it was taught.
- [The Knowledge-Use Study](https://plexara.io/benchmark/knowledge-use/): Agents rely completely on delivered knowledge they cannot re-derive. With the company definition delivered, confident fabrication of institutional facts fell from 75% to zero, and capable models independently re-verified every claim they could check.
- [The Knowledge-Pollution Study](https://plexara.io/benchmark/knowledge-pollution/): We planted a wrong fact through our own review queue and measured what agents did with it. A wrong claim does not out-argue the correct source, it suppresses the check that would refute it, and the exposure sits entirely on cheap model tiers.
- [The Graph-Completion Study](https://plexara.io/benchmark/graph-completion/): Agents asked to write complete operational documents follow references between knowledge pages voluntarily, ground every constraint while reading 0.2% of a 5,000-page corpus, and keep discovery cost flat as the corpus grows a hundredfold. With search off, references are the only route that works.

## Comparisons

- [MCP Data Platforms vs MCP Gateways](https://plexara.io/compare/): Two categories share the MCP label: gateways govern traffic, data platforms serve data. How to grade any vendor, and how Plexara compares to Snowflake managed MCP, Starburst AIDA, gateways, and building it yourself.
- [Plexara vs MCP Gateways](https://plexara.io/compare/mcp-gateways/): MCP gateways route and authenticate tool calls. Plexara executes queries and returns enriched, governed results. Why connecting independent MCP servers does not add up to a data platform.
- [Plexara vs Building It Yourself](https://plexara.io/compare/build-vs-buy/): What a self-built MCP data platform actually contains: federation, enrichment, personas, memory, audit, and a permanent operations tail. When building is right, and what Plexara replaces.
- [Plexara vs Snowflake Managed MCP](https://plexara.io/compare/snowflake-managed-mcp/): Snowflake's managed MCP server reaches Snowflake-resident data. Plexara federates across warehouses, databases, S3, and APIs, enriches every response, and stores your semantics in open formats.
- [Plexara vs Starburst AIDA](https://plexara.io/compare/starburst-aida/): Starburst AIDA is an assistant inside Starburst's interface. Plexara is an MCP platform that makes Claude, ChatGPT, and your own agents experts on your federated data, with knowledge that compounds.

## Learning hubs

- [Learning](https://plexara.io/learning/): AI, MCP, and data context education for enterprise teams. A self-serve curriculum on LLMs, the Model Context Protocol, and the governed context layer.
- [Insights](https://plexara.io/learning/insights/): Technical deep dives, architecture decisions, and perspectives on building the governed context layer for enterprise AI agents.
- [AI Concepts](https://plexara.io/learning/ai-concepts/): Plain-language foundations on large language models, frontier models, and the concepts every enterprise team needs before adopting AI-native data tools.
- [Plexara MCP](https://plexara.io/learning/mcp/): A plain-language introduction to the Model Context Protocol, how it works, and how Plexara extends it with semantic enrichment, memory, and governance.
- [Asset Workflows](https://plexara.io/learning/assets/): Hands-on recipes for the Plexara asset system: creating reports and dashboards, exporting data, and more.
- [Prompts as SOPs](https://plexara.io/learning/prompts/): The Plexara 400 series: saving the procedures your team discovers with the agent as reusable prompts. Letting the agent author them, sharing them, improving them with feedback, and running them.
- [Spreadsheets as Tables](https://plexara.io/learning/spreadsheets/): The Plexara 500 series: uploading a file, registering it as a table beside the warehouse, teaching the agent what its columns mean, joining and sharing the result, and keeping the table current when next month’s file arrives.
- [Automations](https://plexara.io/learning/automations/): The Plexara 600 series: the agent writes a script, Plexara runs it on demand or on a schedule, and the outputs refresh themselves. Authoring, outputs, running, governance, and the weekly review that composes scripts, prompts, and knowledge.
- [Newsletter](https://plexara.io/learning/newsletter/): The Plexara Monthly Dispatch archive: once a month, what shipped, what is worth reading, and one practical tip for teams building on governed MCP.
- [Platform Concepts](https://plexara.io/learning/concepts/): Ten visual explainers of the Plexara platform: semantic enrichment, memory, knowledge capture, personas, security, audit, federated SQL, object storage, and metadata governance.

## Insights

- [Five kinds of memory, and how each comes back](https://plexara.io/learning/insights/five-kinds-of-memory/): A fact, an incident, a person, a link, and a habit are five different kinds of knowledge. Plexara stores each as its own dimension and recalls it the way that kind needs, which is what makes memory across sessions feel like memory rather than search.
- [Two front doors, one governed surface](https://plexara.io/learning/insights/the-developer-surface/): Plexara exposes the same governed surface through an MCP server and a REST API. SDKs connect to both, custom tools extend it, and every path shares one identity, one audit log, and one persona model.
- [What you keep if you leave](https://plexara.io/learning/insights/what-you-keep-if-you-leave/): Metadata you author through Plexara lives in DataHub in open formats. If you stop using the platform, you keep the catalog, the lineage, and the definitions your team wrote. Portability is a property of the storage, not a promise on a slide.
- [Why a Plexara rollout starts small](https://plexara.io/learning/insights/why-a-plexara-rollout-starts-small/): A first deployment connects two or three data sources and one persona, then expands without rewriting what came before. Phased rollout is not caution for its own sake. It is how a complex system that works actually comes to exist.
- [Own the learning loop, not just the model](https://plexara.io/learning/insights/own-the-learning-loop-not-the-model/): A frontier model never learns your institutional knowledge. It only gets better at using what your people supply and frame, so the durable equity is built outside the model: a loop that captures human and model coordination and keeps it inside your own ecosystem. That loop is most of what Plexara already is.
- [When prompts become shared infrastructure](https://plexara.io/learning/insights/governed-prompts-and-relevance-search/): A good prompt is only useful if other people can find it, trust it, and run it. Treating prompts as governed, searchable assets turns one person's good question into everyone's.
- [Closed by default: least privilege as the starting point](https://plexara.io/learning/insights/closed-by-default-access/): Access control that starts open and gets locked down later never actually finishes. Closing connection access by default means every role sees exactly what it was granted and nothing more.
- [Search the capability, not the manual: how Plexara keeps a wide platform light](https://plexara.io/learning/insights/search-the-capability-not-the-manual/): Loading every API spec into context does not scale. A small, fixed tool footprint plus semantic endpoint discovery keeps cost tied to the task, not the size of the platform.
- [Letting the agent find the right tool](https://plexara.io/learning/insights/intent-driven-tools-and-memory/): An agent that rereads every tool description on every turn is slow and error-prone. Selecting tools by intent, and remembering context across sessions, is what makes a wide platform feel fast.
- [The combinatorial platform: when an agent can see across the whole stack](https://plexara.io/learning/insights/when-an-agent-can-see-the-whole-stack/): A warehouse connection tells you what the data is. The valuable questions need an agent that reasons across query, catalog, orchestration, and source layers at once.
- [Meeting enterprise systems where they are](https://plexara.io/learning/insights/enterprise-authentication-and-isolation/): Real enterprise APIs authenticate in messy ways: client certificates, basic auth, second credential headers. Supporting them, while keeping each user activity isolated, is what makes an agent usable at work.
- [Why more tools won't make your agent smarter](https://plexara.io/learning/insights/why-more-tools-wont-make-your-agent-smarter/): An agent with fifty tools and no context is a confident intern with root access. Capability scales with understanding of the data, not connector count.
- [Why an agent needs a versioned API catalog](https://plexara.io/learning/insights/versioned-api-catalogs/): Pointing an agent at an API is the easy part. Making it dependable when the API changes, returns surprises, or needs a second credential is the hard part. A versioned catalog is what turns a connection into something you can rely on.
- [Why proximity matters: tools, meaning, and memory belong together](https://plexara.io/learning/insights/why-proximity-matters-tools-meaning-memory/): Most AI agent stacks are gateways wrapped in auth. The hard work is not routing tool calls; it is making sure context arrives with them.
- [The context gap in AI data access](https://plexara.io/learning/insights/context-gap-in-ai-data-access/): AI agents can execute SQL, but without business context they generate inaccurate queries and untrustworthy results. Not a better model. Better context.
- [Protocols outlast products](https://plexara.io/learning/insights/protocols-outlast-products/): MCP, Trino, and DataHub are open protocols with communities larger than any vendor. Building on protocols, not proprietary platforms, is the durable choice.
- [How knowledge application turns usage into documentation](https://plexara.io/learning/insights/knowledge-application-turns-usage-into-documentation/): Most data catalogs are empty because documentation is a separate task. Plexara inverts this: documentation happens as a byproduct of people using data.
- [Governance at execution time vs. catalog time](https://plexara.io/learning/insights/governance-at-execution-time/): Traditional governance creates policies in a catalog and hopes they are enforced. AI agents expose the gap. Closing it unifies governance with execution.
- [Token efficiency in enterprise MCP deployments](https://plexara.io/learning/insights/token-efficiency-in-enterprise-mcp/): Most MCP implementations waste tokens through tool explosion, redundant metadata fetches, and repeated context. Three mechanisms eliminate these costs.
- [Replacing the five-vendor data stack with one platform](https://plexara.io/learning/insights/replacing-the-five-vendor-data-stack/): The modern data stack costs $300K-$1M per year across 5+ products. Plexara consolidates catalog, query, governance, enrichment, and agent framework into one.
- [Why MCP gateways are not enough](https://plexara.io/learning/insights/why-mcp-gateways-are-not-enough/): MCP gateways solve the plumbing problem but not the meaning problem. A gateway authenticates a tool call. It cannot tell you what the data means.
- [Why incumbent AI assistants are not enough](https://plexara.io/learning/insights/why-incumbent-ai-assistants-are-not-enough/): Every major warehouse vendor has an AI assistant. They work well within their own ecosystem. The problem is that your data does not live in one ecosystem.
- [Why point-solution catalogs and semantic layers are not enough](https://plexara.io/learning/insights/why-point-solution-catalogs-are-not-enough/): Data catalogs document data but cannot execute queries. Semantic layers define metrics but delegate execution. Neither provides unified context and access.
- [Benchmarking the context layer](https://plexara.io/learning/insights/benchmarking-the-context-layer/): We built a benchmark that holds the model constant and varies only the platform. On business-context questions, an agent on raw data tools was right about 43 percent of the time. The same agent on Plexara was right about 99 percent, using fewer tool calls.
- [When do agents use what you teach them?](https://plexara.io/learning/insights/when-agents-use-what-you-teach/): Plexara's knowledge-use study asks what an agent actually does with delivered knowledge. Strong models re-verify anything they can check, and rely completely on the facts they cannot re-derive: conventions, definitions, policies. Without those facts, they invent plausible substitutes 75 percent of the time.
- [Two benchmarks, one conclusion: the industry is converging on context](https://plexara.io/learning/insights/two-benchmarks-one-conclusion/): dbt Labs benchmarked agents on its semantic layer against text-to-SQL and reached the conclusion our platform ablation reached: govern the context between an agent and the data, and business questions move from unreliable to dependable. Two methods, one finding, and a rule for reading both.
- [What one person teaches, the whole team gets](https://plexara.io/learning/insights/what-one-person-teaches-the-whole-team-gets/): An analyst corrects the assistant once and a colleague who never saw that conversation gets the right answer weeks later. Our own benchmark said that mostly was not happening, named the likely cause, and the rerun after a targeted fix says it now happens 98.9 percent of the time.
- [A tool catalog is not a data platform](https://plexara.io/learning/insights/a-tool-catalog-is-not-a-data-platform/): Agent integration platforms now advertise thousands of connected apps and tens of thousands of actions. Catalog size is the wrong axis. What determines whether an agent produces dependable work is what surrounds the call: where the answer lands, who was allowed to make it, and what the platform remembers afterward.
- [The public data your warehouse is missing](https://plexara.io/learning/insights/the-public-data-your-warehouse-is-missing/): The federal statistical system publishes some of the best-maintained data in the world through free APIs: demographics, income, employment, weather, traffic. It rarely reaches a company warehouse because the friction lived in the plumbing. Give an agent a governed gateway to these sources and the friction is gone.
- [When the answer is an action](https://plexara.io/learning/insights/when-the-answer-is-an-action/): Business intelligence has always ended at a finding: the analysis stops, and the action moves to other tools, other people, and next week. An agent that reaches remote systems through a governed API gateway closes that gap. The same session that finds the audience pushes it, schedules the send, and verifies the result.
- [The spreadsheet that joins your warehouse](https://plexara.io/learning/insights/the-spreadsheet-that-joins-your-warehouse/): Ad-hoc CSVs are the most common data silo in business: valuable exactly when joined, stranded in inboxes because loading them was a project. Plexara registers an uploaded CSV, or one an agent built, as a queryable table over the file where it sits, so the join runs in the warehouse instead of the context window.
- [The report that runs without the agent](https://plexara.io/learning/insights/the-report-that-runs-without-the-agent/): An hour with an AI assistant produces the perfect sales report. Re-deriving it every week burns tokens on logic that is already settled. Plexara lets the agent save that logic as a script the platform runs on demand or on a schedule: reports, exports, and dashboards that stay fresh with no model in the loop.
- [Every call your agent makes states its purpose](https://plexara.io/learning/insights/every-call-states-its-purpose/): An AI agent that can query your warehouse leaves a question behind: what did it run, and why? On Plexara every query and API call carries the purpose the agent stated for it, every session can be opened long after it ended, and every saved report names the calls it was built from.
- [The Frontier Report: 2026 Q3](https://plexara.io/learning/insights/frontier-report-v1/): Independent scores for current frontier flagships as of September 2026, written for someone putting an assistant in front of company data.

## Newsletter

- [Monthly Dispatch: September 2026](https://plexara.io/learning/newsletter/2026-09/): Your assistant can hand work to the platform: a report it got right becomes a script Plexara runs on a schedule, a CSV you register becomes a table the warehouse can join, and every query and API call states what it was for. Plus sessions that start lighter, and a tip on asking for the script once the report is right.
- [Monthly Dispatch: August 2026](https://plexara.io/learning/newsletter/2026-08/): The transfer gap is closed: a fact one person teaches now reaches a teammate who never saw the conversation 98.9% of the time. Plus a research center with two new pre-registered studies, email notifications that reach people outside the portal, and a tip on asking for strategy, not reports.
- [Monthly Dispatch: July 2026](https://plexara.io/learning/newsletter/2026-07/): Canonical knowledge pages land, linked like a wiki, and our benchmark goes public: the same agent went from 42.7% to 98.7% correct on business-context questions. Plus a consolidation tip and four outside reads, two of them benchmarks.
- [Monthly Dispatch: June 2026](https://plexara.io/learning/newsletter/2026-06/): A human feedback and review loop lands end to end, the context Plexara attaches to answers now reaches every client, and our flagship piece argues the real asset is the learning loop you own, not the model you rent.
- [Monthly Dispatch: May 2026](https://plexara.io/learning/newsletter/2026-05/): The MCP Gateway reaches general availability and the API Gateway opens in beta. Plus three reads from the Learning section, a reusable-prompts tip, and four outside perspectives on enterprise MCP.

## AI Concepts (100 series)

- [What is a Large Language Model?](https://plexara.io/learning/ai-concepts/what-is-a-large-language-model/): LLMs predict the next token from patterns learned across trillions of training examples. What that means, why it produces fluent reasoning, and its limits.
- [Tokens and your budget](https://plexara.io/learning/ai-concepts/tokens-and-your-budget/): Every LLM interaction is priced and rate-limited in tokens. What a token is, how much text fits a budget, and how to avoid wasting tokens on useful answers.
- [Context, compression, and memory](https://plexara.io/learning/ai-concepts/context-windows-and-tokens/): The context window is a model's working memory. Each session balances keeping, compressing, or clearing it. Plexara adds enterprise memory on top.
- [Frontier models, specialized models, and why enterprise AI uses both](https://plexara.io/learning/ai-concepts/frontier-models-explained/): Frontier models bring world knowledge; small local embedding models power memory and catalog search. Knowing each role designs AI systems that work.
- [What is an AI agent?](https://plexara.io/learning/ai-concepts/what-is-an-ai-agent/): An AI agent is not a chatbot and not magic. It is a short loop (think, call-tool, observe, think again) on top of a language model. Mental model first.
- [Is MCP just an API wrapper?](https://plexara.io/learning/ai-concepts/mcp-vs-apis/): MCP is not a replacement for your APIs and not a thin proxy. It is an application layer on top, like a website is an application layer on top of its APIs.

## Plexara MCP (200 series)

- [Anatomy of a Plexara MCP](https://plexara.io/learning/mcp/what-is-an-mcp/): 201 shows what is actually in the box on a Plexara server: the tool inventory by toolkit, the four content layers, the interactive apps a tool result can carry, and the memory, knowledge, and governance underneath. This lesson is the map.
- [Your first day with Plexara](https://plexara.io/learning/mcp/first-engagement/): A new Plexara user gets connected, sends a first question, and platform_info takes over. Walks through day one and how subsequent turns inherit context.
- [Discovery: one search, then fetch](https://plexara.io/learning/mcp/discovery-search-and-fetch/): One question reaches every system the agent can see. Results come back grouped by source with a coverage summary, and fetch reads any of them in full.
- [Trino Query: analytics and insights](https://plexara.io/learning/mcp/trino-query-analytics-and-insights/): Plexara reaches customer data through Trino. What Trino is, how it maps to DataHub metadata, why OLAP queries finish fast, and how to export large results.
- [Assets: dashboards, reports, and data](https://plexara.io/learning/mcp/assets-dashboards-reports-and-data/): Plexara's asset system persists dashboards, reports, and exports outside chat. Naming asset tools in a prompt saves tokens and keeps outputs shareable.
- [Knowledge: from a memory to something the whole team can use](https://plexara.io/learning/mcp/knowledge-from-memory-to-insights/): Memory to Insight to Knowledge: the three stages a fact travels, the capability check that promotes it, and the two canonical places it lands.
- [Governance: personas, access, and audit](https://plexara.io/learning/mcp/governance-personas-and-access/): Governance in Plexara is enforced when a tool is invoked, not described in a policy. Personas, default-deny, layered safeguards, and a single audit log.
- [The prompt library: versioned, shared, and measurable](https://plexara.io/learning/mcp/mcp-prompts-reusable-prompts/): Two buckets, collections and facets, version history with approval provenance, attached materials, and running a prompt by whatever handle you know it by.
- [Resources: the company files the agent should use, not reinvent](https://plexara.io/learning/mcp/mcp-resources-templates-and-examples/): Your templates, brand files, and reference documents, uploaded once and used as-is: which layer a file belongs on, search then fetch, revisions that keep every citation resolving, and making a template mandatory.
- [Putting it all together: a worked end-to-end example](https://plexara.io/learning/mcp/tool-survey/): A capstone that walks a single real-world question through every Plexara subsystem covered in the 200 series, with a tool-by-tool reference at the end.
- [Governing the catalog without leaving the portal](https://plexara.io/learning/mcp/catalog-governance-in-the-portal/): Tags, domains, the business glossary, context documents, and per-table metadata are edited in the portal, under the same persona grants that govern the agent and in the same audit log.
- [Seeing the shape of what your team knows](https://plexara.io/learning/mcp/the-knowledge-graph/): The portal draws your knowledge corpus as its reference network and measures it: node size is how much of the corpus an entity holds together, and a citation the catalog cannot confirm is stated rather than drawn as if it resolved.

## Asset Workflows (300 series)

- [Creating reports and dashboards](https://plexara.io/learning/assets/creating-reports-and-dashboards/): AI chat tools produce excellent dashboards and reports in HTML, JSX, and SVG, formats that do not move easily through normal business workflows. Plexara gives them a home in the portal under Assets: your team's catalog of AI-built work, shared like Google Docs, stored in your S3, editable in place, and discoverable by future agent sessions. This article is the working playbook, including the two prompting habits that make the agent produce a saved asset efficiently.
- [Exporting data](https://plexara.io/learning/assets/exporting-data/): When a teammate asks for the data instead of the dashboard: a spreadsheet to pivot, a JSON to feed another system, a markdown table for a wiki. Plexara has a dedicated path for this called Trino Export. It runs the query, writes the file straight to your S3 bucket, and never puts the rows in your chat. This article is the analyst's playbook.
- [Sharing your work](https://plexara.io/learning/assets/sharing-your-work/): Sharing in Plexara sends real mail. Name a colleague and they get an email carrying your note and a link that opens the work; name somebody with no Plexara account and they can still read it, through a single-use link sent to the address you named. This lesson is the playbook for getting a dashboard in front of the right person and knowing what happened to it after you clicked Share.
- [Creating collections](https://plexara.io/learning/assets/creating-collections/): A board briefing is rarely one dashboard. It's a dashboard plus a summary plus the underlying data, opened from a single link in the order you chose. Plexara calls that packaging unit a collection. You can ask the agent to assemble one during the same session that produced the assets, or build one by hand on the Collections page. This lesson covers both.
- [Editing what you already have](https://plexara.io/learning/assets/editing-what-you-already-have/): When the dashboard you saved last week is mostly right but needs a fix, you do not re-create it from scratch. You edit the existing asset in place. The link the recipient already has keeps working, the version history accumulates on one asset instead of fragmenting across copies, and any collection that references it picks up the change. This lesson covers the three kinds of edit (metadata, content, revert), what each one does to the version history, and the portal vs agent path.
- [How an asset was built](https://plexara.io/learning/assets/how-an-asset-was-built/): Every asset in Plexara carries two kinds of metadata: descriptive fields the agent fills when it saves the asset (name, description, tags) and that you can edit later, and provenance the platform records on its own. Provenance is the audit trail Plexara captures at the MCP boundary: the catalog searches and queries the agent invoked, with what parameters, in the producing session. This lesson opens that record, names what it can and cannot tell you, and shows how to use it to answer the questions stakeholders ask about a number.
- [Turning a comment into something the agent remembers](https://plexara.io/learning/assets/feedback-that-becomes-knowledge/): A reviewer writes "we don't use that term" on your dashboard. In most tools that comment stays a comment, and the same correction gets made again next quarter. In Plexara an agent can fold it into the knowledge loop: memory_capture with thread_ids records the lesson as a pending insight, resolves the thread, and routes it to the review queue that produces knowledge pages and catalog changes. The person who raised it then confirms or disputes the resolution. This lesson covers the whole loop, the notification rules, the access rules, and how a reviewer with no account participates through a public link.
- [Reproducible prompts](https://plexara.io/learning/assets/reproducible-prompts/): Plexara has a first-class prompt object: a saved instruction template with named arguments that you (or a teammate) can re-run later with different values. Manage Prompts (manage_prompt) is the tool. This article covers what a prompt record actually is, how arguments substitute at run time, which scope to pick (personal, persona, global), the four built-in workflow prompts, and the limits of what re-running a prompt does and does not guarantee.

## Prompts as SOPs (400 series)

- [Prompts are the new SOPs](https://plexara.io/learning/prompts/prompts-are-the-new-sops/): You work with the agent for an hour to get one report exactly right, with a year-over-year cut, holiday annotations, and storm-closure markers. The agent saves durable business knowledge on its own. But that specialized report is not institutional knowledge, it is a procedure. This article draws the line between the two, and makes the case that a saved prompt is the standard operating procedure for an AI-run job.
- [Letting the agent write the prompt](https://plexara.io/learning/prompts/letting-the-agent-write-the-prompt/): The cheapest way to save a procedure is to not write it yourself. The agent that just spent an hour producing your report still holds the tool order, the corrections, and the values worth turning into arguments. Ask it to author the prompt, review the draft, and save it. This article covers the move, why the agent is the better author, and how to read what it produces.
- [Sharing prompts, and closing the loop with feedback](https://plexara.io/learning/prompts/sharing-prompts-and-feedback/): A procedure is only worth as much as the people who can run it. Plexara distributes a prompt two ways: a direct share to one teammate, or a promotion to a whole role or company through the admin review queue. A shared prompt is live, not a copy. Feedback threads then carry corrections back, with a validation step and a path into the knowledge catalog, and the deprecate-and-supersede lifecycle retires old versions cleanly.
- [Running prompts, by hand and on a schedule](https://plexara.io/learning/prompts/running-prompts-and-schedules/): A saved prompt runs two ways: at your keyboard when you want the report now, and on a schedule when you want it to arrive on a cadence. Running by hand takes a sentence: name it to the agent under any handle it knows, pick it in the List Prompts app, or paste the portal’s copyable invocation. Scheduling is not a Plexara feature at all; it lives in your agent, from an in-session loop to a cloud routine that runs when your machine is off. This article covers both, where the output goes, and how a share turns an unattended run into email somebody actually reads.

## Spreadsheets as Tables (500 series)

- [The last mile of data is a spreadsheet](https://plexara.io/learning/spreadsheets/the-last-mile-of-data-is-a-spreadsheet/): The join was never the expensive part of using an outside file. Loading it was, and loading was staffed: a ticket for the table, an engineer for the load, an integration platform somebody had to keep. A chat agent does not close that gap on its own, because a large file does not fit its context and the scripts it writes vanish with the session. This lesson sets out the gap, the registration model that closes it (a table over the file where it sits, nothing copied), and the size rule for when a file needs no table at all.
- [Uploading a file and registering it as a table](https://plexara.io/learning/spreadsheets/uploading-and-registering-a-file/): The mechanics. Upload a file to the resource library with a description search will match, export a spreadsheet as UTF-8 CSV first, register it from the file’s own page or with one sentence to the agent, and read what comes back: the qualified name, the columns, and a sample statement with the cast. Then the Scratch Tables page, where every registration is listed with its state, and the three things a file can be refused for, with the repair that writes a corrected version through the file’s own history.
- [Teaching the agent what the file means](https://plexara.io/learning/spreadsheets/teaching-the-agent-what-the-file-means/): A header row says what the columns are called, not what they mean. This lesson is the five minutes after registration: telling the agent the units, the grain, the effective dating, the join key, and what a missing row means; letting it capture that as memory; promoting the capture to a knowledge page so every teammate’s agent recalls it; and recording the first successful join as a reusable query. Registering publishes the data. This is how you publish the meaning.
- [Joining, visualizing, and sharing](https://plexara.io/learning/spreadsheets/joining-visualizing-and-sharing/): The join, with the cast every registered column needs, run against a real supplier quote and a month of sales: cost change by category, the SKUs whose margin falls under a threshold at the current price, and the SKUs the sheet does not cover. The result becomes a dashboard asset with provenance, shared with the people who need it. The lesson closes with the choice between querying a registered table and having a dashboard reference the file directly, which re-reads it on every open.
- [Next month’s file](https://plexara.io/learning/spreadsheets/next-months-file/): The new sheet arrives. Replacing the file’s content writes a new revision, and the registered table keeps reading the old one until it is registered again under the same name; the Scratch Tables page says so. This lesson covers the two cases that look alike and behave differently, moving the table forward, unregistering, what deleting the file does, saving the monthly procedure as a prompt, and the point at which a monthly file needs more than a join, which is where the 600 series begins.

## Automations (600 series)

- [Do not spend AI on what a script can do](https://plexara.io/learning/automations/do-not-spend-ai-on-what-a-script-can-do/): The report that gets rebuilt every Monday spends tokens on logic that was settled weeks ago and drifts a little each time. Integration platforms automate well but need a platform expert, so a one-off analysis never crosses that bar; an agent on a laptop writes scripts that vanish with the session. This lesson sets out the division of labor the series runs on: a script for the deterministic part, the model for writing it and for judgment about what it produced, and a managed script as the thing Plexara keeps, versions, runs, and schedules.
- [The agent writes the first script](https://plexara.io/learning/automations/the-agent-writes-the-first-script/): From a solved session to a saved script, with the loop the agent works through: create, validate, dry-run, patch, validate, dry-run, save. What a validate report says about the tools, connections, and destinations a script reaches; what a dry run measures without persisting anything; the dialect’s deliberate absences and the three traps that fail a draft; typed parameters; and the script’s own page in the portal with its source, Validate, Dry run, and versions. Grounded in a real script that reads the 500 series’ registered table.
- [Outputs: feeds, reports, and dashboards that refresh themselves](https://plexara.io/learning/automations/outputs-feeds-reports-and-dashboards/): What a run produces and where it lands. One script and one output name is one asset, and every run adds a version; a dated name builds an archive instead. Rows become CSV or JSON feeds; a string body becomes a markdown, HTML, or JSX document. A semi-dynamic dashboard is published once and has only its data region refreshed on later runs, so layout edits made in the portal survive. A dashboard can instead reference a file a script rewrites, capped versions keep an asset tidy, and a named bucket drop delivers the same bytes to another system.
- [Running it: by hand, from the portal, and on a schedule](https://plexara.io/learning/automations/running-by-hand-from-the-portal-and-on-a-schedule/): Three triggers, one run. From any session with a single call, from the Run button on the script’s page where the form comes from its parameter contract, or on a cadence set in the portal’s builder or by the agent, in a timezone, with the fire date pinned onto the run. What a schedule guarantees: one fire is one run, an overlapping fire is recorded as skipped, a gap produces one run for the latest fire, a failed scheduled run emails its owner and is never retried. And the run history that records every trigger, duration, output, and log.
- [What a run may do, and the record it leaves](https://plexara.io/learning/automations/what-a-run-may-do/): A run presents the roles its author held at the save, every call is authorized at that moment, and narrowing the persona takes effect on the next run. A save refuses a credential-shaped literal and source that does not parse. The dialect has no network, no filesystem, and no clock, so everything a script does is a platform call audited under the script’s own identity. The lifecycle from active to disabled, deprecated, and superseded; who sees what; ownership and an administrator’s transfer; and the administrator’s view of every script and every run.
- [Scripts as skills: the weekly review the agent runs on your business](https://plexara.io/learning/automations/scripts-as-skills-the-weekly-review/): The capstone. Three scripts (category velocity, the supplier quote margin review, regional weather context) attached to one prompt, so serving the prompt carries each script’s contract and last successful output and the agent runs them for fresh numbers instead of re-deriving them. The agent then reads the outputs against the seasonality calendar, the returns policy, the store formats, and the stock health bands, and produces the week’s action items: promote, discount, discontinue or renegotiate, watch, each with its figure. The scripts did the data work; the model did the judgment; neither is rebuilt next week.

## Legal

- [Privacy Policy](https://plexara.io/privacy/): Plexara privacy policy. How Deasil Works, Inc. collects, uses, and protects your information. We do not sell or share your data.
- [Terms of Service](https://plexara.io/terms/): Plexara terms of service. Terms and conditions for using the Plexara platform and services operated by Deasil Works, Inc.