Introducing SMEme

Space Coast, FL — I am thoroughly excited to announce SMEme (pronounced smee-mee), the first technology from Arista Labs. SMEme automates expert reasoning without handing the judgment to the model. You author the decision procedure — legal analysis, policy compliance, financial review, and other expert judgment — in language you can read and edit, and a constraint solver, not the language model, computes what follows from it. That pairing of a large language model with a solver is what makes it a neurosymbolic architecture.

I wrote separately about why that architecture matters. In short, the LLM translates, the solver decides what follows, and the human has to be able to read, approve, and edit the artifact in between. This post takes the user's side of that architecture and follows a single case from the first prompt to the finished report.

SMEme is engineered so that you do not have to fine tune a model, learn a formal language or ontology, hire consultants or forward-deployed engineers to put it to work. Setup is one MCP connection from the AI platform you already use (ChatGPT, Claude, and others). The same SMEme tool surface can also be called from programmatic workflows built with Zapier, n8n, LangGraph, ServiceNow, and similar systems.

SMEme Core is distributed source-available under a Sustainable Use License (inspired by n8n), so you can self-host. SMEme is also offered as a hosted service with a generous free tier at smeme.ai.

We want AI to expand human agency, and we want to earn revenue through a transparent, fair, and consensual exchange of value. Arista Labs never shares or sells your knowledge artifacts or any of your information. You control the knowledge artifacts you build. You can create, update, delete, and share them as you see fit. Delete a decision tree and the compiled artifacts behind it are deleted with it.

Legal reasoning, directly in chat

Consider a U.S. company negotiating a cross-border deal with a foreign business. Counsel must determine how the payments should be characterized and whether the U.S. company has an obligation to withhold tax.

The lawyer — or their client, preparing for a consultation — works in an MCP client such as ChatGPT or Claude Cowork:

I want to build a new SMEme decision tree. It needs to determine when a U.S. company has an obligation to withhold taxes during a cross-border deal with a foreign business. I’ve added several files that can be taken as authoritative concerning the rules and context for the decision tree to the local project folder. Do a web search and research current IRS, treaty, tariff, and other relevant authorities and updates.

That is enough semantic nudging for the agent to find the SMEme MCP tool smeme_authoring_design_guidance and draft the decision tree in the prescribed JSON format. The tree becomes — and remains — a user-owned artifact. SMEme processes it, but never shares it; you can. It downloads as JSON for peer review, for testing, or for a colleague who wants to run it themselves.

There is also an AI-assisted wizard on the SMEme web app. Users can upload files, use AI-enhanced web search, and build the tree in a deterministic save-as-you-go experience. In either path, the LLM can use the decision tree as context while the user reads, edits, and maintains it.

Once the user is satisfied that the tree represents their decision process, including the possible outcomes, a simpler prompt is enough:

Send this tree to SMEme for validation.

The structured JSON goes to SMEme Core through smeme_authoring_validate_graph. If the tree is invalid, SMEme returns a rich error and the agent can edit with your input until validation passes. smeme_authoring_create_draft then saves it as an unpublished draft on the SMEme dashboard.

Nothing is deployed automatically. When the author is ready, they click Deploy on the dashboard. That click is the commitment that triggers SMEme to deterministically compile the reviewed tree into a frozen intermediate representation, and that artifact — not the tree still open in the editor — is what the reasoning tools run. Later edits do not change it. The dashboard marks a tree Live while the saved graph still matches what was deployed and Stale once it does not, and evaluation refuses a stale tree rather than reasoning under rules the author has not approved. Earlier deployed artifacts are retained, so a result from last quarter stays interpretable under the rules it was actually evaluated against. Deploy, Redeploy, listing or hiding a deployed tree, and deleting one all happen on the dashboard. Authoring, validation, drafting, and every reasoning call are available to agents and programmatic workflows.

When a new matter arrives, counsel runs whatever facts have been gathered so far:

Run my SMEme cross-border tax withholding decision tree on the ACME, Inc. matter concerning their sale of asset X to party D. The matter is already tracked in the CRM as matter #123. I’ve put a few files in the local project folder. Make sure to check the cloud drive for the associate’s intake diagnostic memo. There’s been some email correspondence you need to check as well.

The agent finds the deployed tree with smeme_reasoning_list and opens an Inquire session with smeme_reasoning_evaluate. Inquire is the mode for cases assembled as you go. SMEme returns one question at a time, with the valid answer choices for that question. The tree’s topology is withheld from that task, so the agent cannot see the other questions, the branching conditions, or the possible conclusions, and it does not choose what comes next. Withholding the payload is structural. Keeping the model from reconstructing the tree out of earlier turns is a matter of instruction, since ordinary chat retains its own context. Where a case would demand genuinely isolated verification, SMEme stops the chat loop rather than pretending that isolation held.

For each question, the agent gathers facts from the agreement, email, corporate records, tax forms, prior research, and other local or MCP-connected sources. To admit an answer through smeme_reasoning_evaluate_continue it must attach a provenance identifier pointing at the source it drew that answer from, and where it cannot find the fact it can abstain instead of guessing. Provenance records where a proposed answer came from, not whether the source establishes it. Weighing that remains counsel’s judgment.

Counsel can review the evidence, inspect the cited sources, override an answer, add another source, or ask the agent to resolve a contradiction. Overriding an answer is a revision rather than an addition, so SMEme re-derives the case from the corrected answer set instead of carrying forward what the old one supported. The session is durable. It can be left and resumed if more information has to be gathered.

This uses the LLM for searching, reading, comparing, deduplicating, and structuring language — the work it is particularly good at. SMEme decides what to ask next after each answer is admitted. The loop continues until SMEme returns a report.

Where counsel already holds a complete answer sheet — an audit pack, a matter triggered from the CRM, a pre-filled diagnostic — the second mode runs the same tree in one pass. That mode is Apply. The agent calls smeme_reasoning_template_get, smeme_reasoning_validate_answers, and smeme_reasoning_evaluate_answers. Apply reasons over the same deployed artifact, but it stops on a different rule, so it can report a single outcome in a case where Inquire would still ask another question.

Neither mode needs a model to supply the answers. Because a deployed tree fixes its question identifiers and its allowed answer options, an external workflow can bind each question to a predetermined API call, database query, parser, or calculation and return a reproducible answer. Apply submits those answers as one sheet. Inquire can be driven the same way a question at a time, with the workflow reading the identifier SMEme just asked about and running the routine bound to it. Answers from a routine and answers from an agent pass through the same admission gate.

If the facts support a conclusion, the report comes back concluded, with that conclusion and the decision path associated with it. Otherwise it reports that multiple outcomes remain possible, that more information is needed, or that the admitted answers are inconsistent — SMEme says which, rather than fabricating a single answer.

The reasoning tools stay in the same chat:

• What changes if the services are performed outside the United States? — smeme_reasoning_what_if
• Which of the admitted answers were doing the work behind the withholding conclusion? — smeme_reasoning_decisive_support
• What facts would have to change to reach a different conclusion? — smeme_reasoning_list_conclusions, then smeme_reasoning_how_to_reach
• Would changing this answer break the path the current answers force? — smeme_reasoning_edit_affects_path

Every result is structured, and can inform downstream work. The LLM can draft a memorandum from a prepared template, prepare questions for the counterparty, update the deal record from a CRM runbook, or compose an email to a reviewing partner. New facts come in; context changes; run it again. Tariffs shift or new thresholds appear; work through the same chat agent to revise the tree and validate it, then Redeploy from the dashboard.

The LLM chooses how to read the file and which answer to propose. SMEme decides whether that answer is structurally admissible, what to ask next, and what follows from the authorized tree. The consequence relation is handled by a constraint solver under a published Decision-DAG calculus, not by the language model. SMEme supplies the determinate result under the legal analysis counsel authorized.

Because the model's work stops at translation, every improvement in it accrues to SMEme without touching the gate. As models get better, SMEme gets better. A growing industry is betting on the same premise from the other direction, capturing how experts think and turning it into training data, which sharpens exactly the translator SMEme depends on. Training internalizes expertise into weights, while SMEme keeps the authorized procedure external, inspectable, revisable, and user-owned — never training data for us or anyone else. That contrast deserves a post of its own ... stay tuned.

In this example the user starts in chat and stays in chat, except for the login and the dashboard click to deploy. A natural next use case is verification, checking an LLM-generated decision against an approved corporate policy or compliance regime.

We look forward to seeing how you SMEme. Try it free at smeme.ai. The MCP reference is public, and SMEme Core is on GitHub. The architecture write-up states every implementation claim against a pinned build and says plainly what SMEme does not certify.

Dan Arista, PhD
Founder & Managing Member
Arista Labs, LLC