Tag: mentat

Always Future Agents

I’ve been interested in software agents since I came across Graham Glass’ software ‘ObjectSpace Voyager’ in 1998. The idea behind agents is software that can act on its own on behalf of it’s “owner”, much like a human agent in the sports or entertainment field.

If you’ve ever used something like Spotlight, you’ve used a local agent. Spotlight works away in the background indexing the files on your computer so that it can answer questions like “Where did I put that presentation where I mentioned ‘Bitcoin futures’?”

There are quite a few “local agents” that are useful. But what if it’s someone else’s presentation that you are looking for? What if it’s on their laptop? To be truly useful to their owners, agents must be capable of being distributed.

In 1998 Object-Oriented was all the rage, but distributed software was still a mess. If there was a lot of money riding on it, you could use CORBA. I was significantly techy back then, and even I had trouble with CORBA. Java had Remote Procedure Calls (RPC) calls by which objects could message other objects, but the whole edifice of distributed computing was fragile. There was no platform on which you could write distributed communicating agents.

Then along came Voyager. At a stroke, Voyager let you turn a Java object into an agent that could communicate with other agents wherever they were. More amazing still was that an agent running on Voyager on your machine could “hop” to another device and execute there. It took my breath away.

Sadly, it was also useless. Almost nobody else had heard of Voyager or seemed to see its potential. There was nowhere for your agents to go and nothing much for them to do if they got there. I could never see how to make real use of it. I think this reality started to bite because Voyager pivoted and became a good, boring web application server.

But for a brief moment, I saw a beautiful future of agents communicating with each other to help their users solve problems (yes, Tron made a big impression on me as a child)!

Though it faded over the years, I’ve never entirely lost that vision. It sits as an, as yet, unexplored part of Mentat. In Mentat, scripts are a first-class citizen, and I want to make it easy to create agent scripts that perform functions on my behalf. The distribution will be achieved using TupleSpaces (an overlooked concept in distributed computing).

A simple but powerful use-case could be finding answers to questions. Imagine something like this:

  • You pose a question and post it.
  • One of your agents sends the question metadata to one or more shared tuple spaces.
  • My agents are waiting for tuples matching things I am interested in.
  • One of my agents spots your question and, realising it (a) matches my interests and (b) meets my priority requirements, ‘takes’ it.
  • It presents your question to me along with the related resources that I have on hand.
  • I select from among those resources to compose my answer.
  • My agent posts my answer back into the tuple space.
  • Your agent spots an answer and collects it to present it, and potentially others, to you at an appropriate moment.

Sounds a bit like posting a question to a web forum, right? Yes, but the differences have the potential to be transformative.

  • You don’t have to decide where to put your question; your agent can do that. Depending on your preferences, it might put it in many spaces and with different metadata depending on the space.
  • I don’t have to look for your question; my agent decides if it’s something I will want to respond to. Or ignore. Or maybe just file it away for some other purpose.
  • My agent can assemble resources on my behalf to make it easier to answer that question.
  • You don’t have to look for replies; your agent will assemble them. Potentially using a quality filter (oh, Matt replied, you’ll want/not want to see that) and potentially digesting answers. Your agent might just as well say, “You’re busy right now, but I suspect you’ll want to see Matt’s question; I will present it at another time”.

Since our agents are software under our control, we can determine how they work and improve them over time to better use our knowledge and attention.

For example, your agent might not be tasked with trying to answer my questions but simply to reflect, “Matt seems to be interested in topic X right now”. Indeed your agent might notify you not about my questions but with analysis of my questions. This could go in all kinds of directions.

I have many of the pieces of this infrastructure in place but can’t make progress right now. I really wish I could find someone to collaborate with on this platform. Hopefully, I still have a few years to get back to it and turn it into something real that people can use to solve problems.

Sharing our work

When I started working on Mentat back in 2018 I had in mind a kind of “total information store” that I could use for all sorts of things but often about outputs either to questions or in terms of content.

This was a reflection of the blurring of my work & life and the way that information tends to disappear into other peoples silos over time. I am interested in what I am interested in, no matter the context, and I would like to know what I know or at least what I thought at some point.

Meanwhile, Roam Research has come along and hoovered up a lot of use cases. I use Roam as a habitual note-taking environment. A light-weight TODO system, calendar, and personal CRM. I use it for drafting LinkedIn posts, blogs, and newsletters. And I’m a relatively unsophisticated Roam user (for example I’ve never written a query in anger, don’t use Roam/js plugins, and still use the default theme) and yet it has certainly come to dominate my digital life.

At the same time, I can reflect that one of Roam’s great strengths: its focus on blocks of written text (with tags and backlinks) is also its Achilles heel. You can put anything in Roam but structure appears only sporadically and with effort. How can you act upon what Roam knows?

In the context of, say, writing an article it works well. But what if I wanted to see if I could answer a specific question relating things that I know. That could be a lot more tricky.

Mentat comes from the opposite perspective. It deals with structured ‘things’ (indeed the root of the Mentat mental taxonomy is something called Thing). We can have a Thing called Note that represents free text. This is never going to be as powerful as Roam but, at the same time, we know what is a note and what is a instead a Person. Roam can approach this through the use of tagging. I routinely add Tags: #Person to people I add to Roam as part of my CRM but it’s not the same thing.

As yet, Roam provided few tools to act on this and of course it relies upon my consistently tagging people — which often I forget — and applying the same schema over time (mine has changed 3 times as the advice has changed). Again there are solutions to these problems but they are always a compromise of being based upon free text. Mentat has it’s own compromises but, similarly, strengths.

Three things I see as being very important to using a future version of Mentat for work are:

Being able to structure questions with appropriate metadata that allows them to be shared and acted upon by others.

A “shared space” in which questions can be placed and taken.

The ability to create agents that can act on things in the shared space. Taking them, acting upon them, changing things locally and potentially placing things back into the shared space.

Roam is going to have to tackle the problem of people sharing their graphs. That is going to be a hard problem. Mentat will allow people to create shared spaces and exchange information without needing to create a total mapping.

It will be interesting to see if (a) I can build this, (b) if it might work as well as or better (for some problems) as what Roam will come up with.

Betting big on Roam Research

I’ve been using Roam Research as my primary note-taking and writing tool since December 2019. It immediately struck a chord with me, despite numerous short-comings something fundamental felt right. The fundamentals of the concept were sound.

This caused me an immediate problem since I had been working on Mentat (since early 2018) as my primary note-taking tool. However, Roam caused me to rethink what a note-taking tool should be. At that point, I took that out of my requirements for Mentat. There are enough itches left to scratch and I am interested ??when Roam has an API ? to wonder what I might do with them both.

The Roam team have announced their pricing of $15/month or $500/5-years. I was one of those who “liked” the tweet announcing their $500 “believer” plan as an indication I’d be up for it.

I do have some disagreements with the team (I guess with Conor) in terms of how they have prioritised work in some areas. But I feel like, overall, they are on a good track and while there are (and will be) other tools, Roam and its team, is worth betting on.

So I will be signing up for the $500 when it’s available and looking forward to seeing where the application goes.

Mentat containers

For pretty much a year, i.e. the point at which Mentat became an app that you could run and create Things, the model of containment was very simple: you had Workspaces and workspaces contained Things. The end.

This had the benefit of being simple but it chafed. I had been pondering adding layers as a way of hiding Things that you didn’t want to work with. In trying to implement this I realised that I was skirting around the fact that I needed nested containment. And I was skirting around it because I thought it would be hard to retro-fit.

As it happens it was not as hard as I imagined and it lead to a great simplification of the model. Things can now contain Things and Workspaces are now Things, that contain Things (but not other Workspaces). At some point Workspace is going to be renamed Application which more suits the concept I originally had in mind.

Now I have nested containers implemented and a more consistent data model, which is good. The UI needs to catch up but that will come soon.

Containment was the last of the big ticket items from the original 1.0 roadmap. And so I get closer to a (private) release.

Database for life

How much information have I acquired in my life? Where is most of it? The answer to the former I don’t want to think about too much. The answer to the latter is “lost or locked away”.

I’ve long had the notion that I needed to build a ‘database for life’ in which I could store the information I acquire and want to use. That it should not get locked into silo’s but be available for new purposes and applications.

This is why I have tried to build a Mentat-like application about 4 or 5 times since about 1996. I want to “own” my information. That is, I want to know what I have, I want to build the new on top of the old, I want to relate things together, discover new things. And then I want to make use of it all.

In my concept of Mentat, it is able to grow alongside my information and use cases.

Introducing Mentat

Mentat is something I am going to be talking about on this blog so I guess I should introduce it so here it is?

The Mentat “System” workspace contains useful objects for building applications.

Doesn’t look like much, does it? Nevertheless, it is the culmination of over a year (I broke ground on 6th March 2018 at which point it was called “Codename: Galois”) of stolen evenings and weekends working on it.

In simple terms, Mentat is a tool for storing and manipulating knowledge to create new relationships and new forms. In this, is my response to the likes of Evernote, Tinderbox, and TheBrain.

While I have a lot of respect for each of these applications (I’ve been an Evernote & TheBrain user since the early 2000s) they all fall short of my vision of such an application. Here is a summary of why:

  • They are focused on notes and text. While it is important to be able to take notes, much information requires structure to be useful. Headings are not enough. Mentat represents concepts as a set of typed attributes. So, while Mentat is perfectly capable of being a “note taking” app it is designed to represent and work with structured information (essentially a note is a type of attribute it can work with).
  • They are not scriptable. Okay, this is certainly a lie as Tinderbox does have scripting support. But it uses its own, homegrown and rather quirky, scripting language which I could never get on with. I suspect a lot of Tinderbox power users are not programmers. Mentat uses Javascript and is gradually exposing a sane and consistent API to scripts.
  • They are not customisable or hard to customise. By which I mean you cannot turn them into other applications. They do what they do and it’s very hard to change their form or function. I give credit to Tinderbox that it tries to offer a lot of things people will want.
  • They do not see the world in terms of APIs. The ability to access data from other sources and to work with APIs is paramount to solving real problems. Mentat is designed to have 1st class support for talking to APIs.
  • They are silos. What I mean by this is that they are designed mostly to store and search for information. This is no doubt very useful. But I want to be able to synthesize new information and I want a tool that makes this easy(ier). Mentat is designed at the outset to let you create new Things and export them in different forms.
  • They do not facilitate a collaborative environment. Sure you can share folders and notes but this is very coarse-grained (not to mention a recipe for synchronisation errors). What if we could share particular objects of knowledge and their relationships and act on those as others change them? Mentat doesn’t do anything like this right now but its certainly an aim.
  • They do not fit me. They don’t work the way I want to work. This is a classic problem for all programmers. Being able to code means you can scratch any itch you like. It is also a curse because you keep wanting to scratch itches that you probably shouldn’t. This particular itch has been with me for over 20 years (this is at least my 4th attempt to solve this problem) so I guess I can claim I am justified on this one. While it may fit no-one else, Mentat will fit me!
Mentat represents concepts (which it calls ‘Things’) as a set of typed attributes.

A number of straws broke the camels back to set me off on building Mentat. They were the three, in some senses quite trivial, workflows that chafed a lot. The first was my ASPECT cards. I built these in Adobe InDesign using its ‘Data Merge’ facility. This takes a template representing a card and merges data from a CSV to create a set of card fronts or card backs. It’s pretty cool.

But the information that goes on those cards does not properly live in a CSV file. I tried many approaches to representing it. A structured note in Evernote, AirTable, linked thoughts in TheBrain. Nothing worked. In many cases, the problem got worse when I wanted to get updated questions or different sets of questions into a new CSV file.

The second problem was my database of quotations. I have collected quotations over many years and ended up storing them in a big note in Evernote. I could have broken them up into separate notes and tagged them but it always felt clunky to do so. Even properly organised though, Evernote didn’t let me do anything with them. At the end of the day, the only thing I can do is copy and paste somewhere else.

Lastly I collect questions generally. I want to make sets of these and turn them into “packages of knowledge”. No tool I could find would allow me to represent a ‘package of knowledge’ with questions, concepts, answers, systems, theories and so forth. Nor would they let me share these in any meaningful way.

Mentat started life to answer these three use-cases along with many others that came out of the woodwork once it became a “real” application and I could start playing with what I had made.

I had planned to release Mentat 1.0 on 6th March 2019. A year after breaking ground. Realistically, although it always seemed ‘close’, it wasn’t ready even for me to start using so how much less anyone else.

I recently discovered that Evernote spent 2 years (and with a team working on it) in private development. I realised my “one-year anniversary” thing was arbitrary & putting me under a lot of pressure so I dropped it. So Mentat 1.0 will be released approximately when I am happy with it. That might be towards the end of 2019, or maybe the first half of 2020.

Technical details. Mentat is a macOS application written in Objective-C. Most of it should be broadly portable to iOS and that got a lot more important when I discovered how much I love my 12.7″ iPad Pro. But an iOS release is a very secondary objective at this point.

If you are at all interested or have any questions please leave a comment or ask for an invite to the Brain Tools slack.

As a footnote, Mentat is also, to some extent, a homage to Dave Winer‘s Radio Userland. Sadly departed Radio was a wonderful environment because it treated users like grownups. That was something that, however much Dave’s personal choices chafed, I respected. So, like Radio, Mentat is quirky and opinionated. Like Radio, Mentat is designed to let you get under the hood and tinker. Like Radio, Mentat has a purpose but you can change that purpose to make it closer to your own. Like Radio, Mentat has a few bugs 🙂