Autonomous NanoTechnology Swarms (ANTS)

Nasa is working on a technology called Autonomous NanoTechnology Swarms (ANTS) that is designed to be able to nimbly navigate a difficult and hostile terrain such as Mars. In addition to to flexibility of each node, the entire structure of nodes can shift its shape as conditions warrant.

Although this is obviously a "robotics" technology, the same concepts are quite relevant to software agent technology.

My attention was brought to this announcement by a post on Slashdot.

-- Jack Krupansky

What do YOU mean by "software agent"?

Although I've answered the question "What is a software agent?" as definitively as I can at this time, it does remain an open question. In particular, does a computer program have to exhibit significant signs of "intelligence" before it can be considered an "agent"? Does a program need to be significantly "autonomous" (in terms of choosing what tasks to pursue and where and how) to be an agent? And, to what extent does the program need to have broad latitude to pursue "Goals" rather than being merely "programmed" for a specific task? And what of "swarms" of "dumb agents", are they agents or not? These are all good questions.

For now, I will stick with my primary definition of a software agent:

A Software Agent (or Autonomous Agent or Intelligent Agent) is a computer program which works toward goals (as opposed to discrete tasks) in a dynamic environment (where change is the norm) on behalf of another entity (human or computational), possibly over an extended period of time, without continuous direct supervision or control, and exhibits a significant degree of flexibility and even creativity in how it seeks to transform goals into action tasks.

That said, I am reconsidering whether I really need to have a five-part definition, which recognizes five distinct categories of "agent":

1. Any computer program which is external to a given program and appears to be directly associated with a user. For example, a web server views a web browser as a "user agent". In some ways this is merely referring to any "client" as an "agent".
2. Any server-based program which is monitoring and interacting with one or more web services or network resources. From the perspective of a web service, the external programs are "agents" that are working on behalf of some user or some other server software elsewhere, but the interaction with the "agent" is not directly controlled by a user.
3. An autonomous program which performa well-defined tasks for a user, but doesn't quite measure up to the level of true "intelligence".
4. An intelligent agent which works on behalf of a user and performs at a level that would be considered "intelligent" and far beyond the capability of a non-AI computer program. When confronted by such a program, even a very sophisticated user or software professional would ask "Wow! How does it do that?"
5. A relatively "small" computational entity designed to work in parallel and in conjunction with a relatively large number of similar entities to accomplish goals using "swarm-like" behavior. Each entity has only rudimentary capabilities far below the level that we would associate with intelligence, but the combined "swarm" actually does perform at a level that we would associate with intelligence.

This is all a work in progress, but these are my latest thoughts. I'm struggling to maintain my focus on advancing software agent technology, while at the same time recognizing current technology and current vernacular.

And finally, I would note that the discussion of my current definition does include much of these "new" ideas.

Part of my motivation here is that I seek to expand the audience for my work, but I recognize that the vocabulary, beliefs, and expectations will vary widely for those outside my immediate, past sphere of interest.

-- Jack Krupansky

Natural language feedback for software agent programming

Here are a few more thoughts about the recent story of a program that translates natural language to code. I'm coming at this from the point of view of intelligent software agents. Since agents operate autonomously, we need to be very sure that they are programmed properly since we won't be there to notice, let alone correct any bad behavior.

I'm agnostic on the issue of what language should be used to "program" an agent, whether it be natural language, a "structured" subset of natural language, a classic programming language, AI techniques, etc. What I'm not agnostic about is that there has to be a feedback loop and intensive environment and stress simulation during the development stage, prior to deployment.

One of the valid roles of natural language is to have in-depth analysis tools that analyze the "programming" of an agent and report to the user (or "programmer") the implications of the agent's programming. Essentially, the user needs to know what will happen when the agent goes off and "does its thing". Not the details, but the behavioral effects. Simulated scenarios are essential, but the natural language feedback is just as essential. Graphical or quantitative feedback can also be valuable, but natural language feedback will be the absolute core requirement.

Natural language also has a sterling role to play for reporting results of software agent execution.

Imagine it... send your software agent out to snoop around, and then have it tell you in simple natural language what it saw on its journey.

Natural language also has a role for enabling agents to query the client in situations where guidance is required. Whether natural language can be used as an input at that stage is an open-ended question, but the software can certainly frame questions that can be answered in a more rudimentary manner.

-- Jack Krupansky

Metafor: Translating Natural Language to Code

There is a post on Slashdot entitled "Metafor: Translating Natural Language to Code", referring to a Technology Research News article entitled "Tool turns English to code". The gist of the story is that researchers at MIT, including Hugo Liu, are working on a "language-to-code visualizer" that they call "Metafor". I haven't carefully read either the article or the actual research, but there is at least some utility to pursuing research in this direction.

Here's the Metafor project description from Hugo Liu's web page. There's a breief description, as well as links for papers on the topic, and even the draft for section on the topic for an upcoming book on the topic.

The only real problem I have with the overall concept is that people, including software developers and non-developers alike are particularly lousy and imprecise in their use of natural language. In order to finally achieve the goal of allowing users to fully command and control complex computational systems, we first need to "crack the nut" of how to get people to use natural language more effectively.

To me, the must intriguing avenue of pursuit is feedback tools which allow the computer to elaborate the meanings and ambiguities in any natural language utterance. I would call this "Did You Really Mean?" analysis. It would be quite helpful in all venues of human communication, even if the computer is not the intended target.

-- Jack Krupansky

Service-Oriented Computing (SOC) and Agent-Based Engineering (SOCABE)

There will be a workshop entitled "Service-Oriented Computing (SOC) and Agent-Based Engineering (SOCABE)" at the upcoming Conference on Autonomous Agents & Multi-Agent Systems (AAMAS'2005). As the workshop announcement puts it:

Service-Oriented Computing (SOC) is a newly emerging paradigm for distributed computing and e-business processing that utilizes services as fundamental elements to enable building agile networks of collaborating business applications distributed within and across organizational boundaries. Services are self-contained, platform-independent computational elements that can be described, published, discovered, orchestrated and deployed for the purpose of developing distributed applications across networks, including the Internet. Service-based approaches include Web services, Semantic Web services, and Grid services.

While a service need not fulfill all characteristics of a strong definition of agency, the SOC approach to building complex software systems bears many similarities to the development of agent-based systems. In particular, large systems are assembled from distributed heterogeneous software components providing specialized services and communicating using agreed-upon
protocols. Similarly to certain multi-agent engineering paradigms, the design process of such systems focuses on the declarative characterization of the agents' capabilities and on a message-based paradigm of interoperation. Also similarly to multi-agent systems, management of the service provision processes is dynamic and distributed, and takes into account the requirements both at the individual services and system levels of the composed application. It also needs to be adaptive in response to the changing requirements, services and exceptions
in the dynamic Web and Grid environments.

The area of Service Oriented Computing offers much of real interest to the Multi Agent System community, including similarities in system architectures and provision processes, powerful tools, and the focus on issues such as quality of service, security and reliability. Similarly, techniques developed in the MAS research community promise to have a strong impact on this fast growing technology.

Although "services" certainly is a popular marketing buzzword these days, and software agents will undoubtedly need to interact with so-called "services", the real future of both software agents and "services" is to implement the services themselves using distributed software agent technology, what I call an "agents everywhere" strategy.

The problem with the current vision of services is that they are for the most part simply repackaged mainframe or client-server applications, with all the same associated scalability, reliability, and security concerns. But, it is the "state of the art" at this junction, so we have to learn to live with it, for a while longer.

-- Jack Krupansky

Self-reconfigurable modular robots

Here's a fascinating post on Engadget entititled "M-Tran self-reconfigurable modular robot", which mentions a new form of robot created in Japan that is actaully able too assemble and reconfigure itself using evolutionary genetic algorithms. This is a hint of the kind of flexibility that we will see in intelligent software agents in the coming years.

It doesn't sound like they have endowed the robot with the ability to seek out and interact with other reconfigurable robots, but give them time... "Legos of the world, unite!"

-- Jack Krupansky

Polling and pinging considered harmful

I recently posted some comments entitled "Polling and pinging considered harmful" over on my Base Technology blog. My concerns there were split between overall network architecture and the impact on what the user sees and experiences. Here in the world of software agents, I still have the overall network architecture concerns, but the user is replaced with software agents and the developers and users of those agents.

If and when software agent technology is ready for prime-time, software agents will place enormous demands on our network infrastructure, far beyond the demands of sluggish human users. The idea that software agents should be polling and pinging to access information is completely ridiculous, except for low-volume or localized applications.

For widespread adoption of true software agent applications we simply must have a true information distribution architecture that attempts to optimize information flow rather than forcing a maximization of dysfunctional information flow.

-- Jack Krupansky

Intelligent agents stink (?)

I ran across an old 1996 WIRED article by Jaron Lanier (the guy who coined the term "Virtual reality") entitled "My Problem with Agents" which he leads with the statement "Intelligent agents stink." One of his key statements is that:

If an agent seems smart, it might really mean that people have dumbed themselves down to make their lives more easily representable by their agents' simple database design. This is a serious problem because it could sneak up on us. People are so much more flexible than computers and so prone to suggestion. ... Agents would be - like the television commercial - a simple device that causes a grand decrease in the beauty and intelligence of our society.

He concludes:

The whole point of the Net is the empowerment of the people, not the computers. That happens only if people choose to be empowered. Let's not blow this chance for more human autonomy because we're caught up in the fantasy of machine intelligence.

So, the big question is whether intelligent agent technology and machine intelligence have made any significant progress in the nine years since Jaron made his critical assessment of software agent technology.

In other words, do intelligent agents still stink?

I'll allow readers to jump to their own conclusions, but I'd note that at the present time, machine intelligence seems to work best when it is embedded within a system rather than directly exposed to a user. From this perspective, the question I'd pose to Mr. Lanier is whether he would prefer that systems be composed of dumb components or smart components.

That said, I'd say that we have quite a distance to go before the typical system is based primarily on smart let alone truly intelligent components.

-- Jack Krupansky

IlliGAL Blogging

It sounds ominous, but IlliGAL Blogging is a blog by current and former members of the Illinois Genetic Algorithms Laboratory (IlliGAL) dedicated to studying nature's search algorithm of choice, genetics and evolution, as a practical approach to solving difficult problems on a computer.

IlliGAL is part of the General Engineering Department at the University of Illinois at Urbana-Champaign.

I envision that genetic algorithms will be a key ingredient of intelligent software agents in the coming years.

-- Jack Krupansky

Monitoring machinery health with DEXTER Agents from Macsea

Macsea Limited is marketing DEXTER Agents software agent technology for machinery health monitoring. As their web site notes:

The philosophy behind DEXTER Agents is to provide you with new tools to automate the equipment monitoring and performance analysis functions currently performed by your people. As the levels of plant automation increase, there’s simply too much process data to convert into useful business (maintenance) information. DEXTER Agents allows you to create software agents that automatically perform these tasks, 24 hours per day, 7 days per week. It’s a simple process to create a prognostic agent that acquires process data, performs historical trending analysis to detect anomalous equipment behaviors, and predicts failures before they have a chance to happen. The agents alert you if a problem is detected, otherwise they continue to do their job unobtrusively in the background as part of your enhanced automation system.

See the press release for the latest release of DEXTER Agents(TM).

-- Jack Krupansky

Software agents and Smart Grid Technologies

A workshop which combines software agents and grid computing entitled "Smart Grid Technologies" with he held at the 2005 Conference on Autonomous Agents and Multiagent Systems(AAMAS 2005). The announcement states:

Grid Computing is a novel and active research domain for complex, dynamic, distributed, and flexible resource sharing. Recent research on Grid has largely focused on issues of performance, scalability, and standardization. Yet, little has been done on aspects of intelligence and adaptability. Agent and multi-agent technologies provide a promising approach to make Grid technologies and solutions based on Grid technologies smarter, more flexible, and adaptable.

The kind of questions which arise in this research area are twofold: On the one hand, technical questions concerning the Grid have to be solved, including advanced Grid architectures, semantically enhanced service descriptions, and the specification of resources. On the other hand issues related to autonomy, collaboration, and economic models need to be tackled. Key issues here are market-based allocation and scheduling of resources, pricing, payment, automated negotiation, market mechanisms, self-organization and learning, engineering of Grid marketplaces and many others.

The workshop focuses attention of the following topics:

• Modeling of Grid environments
• Agent-based mechanisms for Grid markets
• Resource allocation in Grid scenarios using agent-based approaches
• Automated negotiation for Grid resource allocation
• Agent-based simulation of Grid environments and markets
• Agent-based Computational Economics for Grid
• Engineering of Grid markets and Grid architectures
• Technical research on future application domains

My personal thinking is that this overall topic is really two distinct sub-topics:

1. How to apply software agent technology towards making grid computing a more usable platform for distributed applications. I would call this "application of software agent technology for enhanced grid operations."
2. How to make grid computing environments better places for the deployment of software agent-based applications and multi-agent systems. I would call this "grid support for software agent applications".

The workshop announcement seems focused on the former, but I think the latter will be inevitable. Either way, the whole topic is quite interesting and quite topical.

-- Jack Krupansky

Intelligent agent vs. dumb software agent

You might ask how an "intelligent agent" is defined such that it's different from any other software agent. Unfortunately, there's no clear, consensus answer. Some people toss the label "intelligent" around as a piece of marketing hype and others prescribe specific, human-like capabilities. Sure, I have my own definition for "intelligent agent", but even it needs more work.

One of the keys to being truly intelligent is that intelligence requires the ability to learn, which is the ability to acquire knowledge and then use to use that knowledge to effect a change in behavior. But maybe that's a little bit beyond current technology.

I would say that an agent should be defined as an intelligent agent only after it can begin working at the level of goals and breaking goals into sub-goals rather than merely being programmed for specific tasks.

-- Jack Krupansky

Software agents for ecologies of innovation

I just saw a reference by Mitch Kapor to "ecologies of innovation". Despite the vagueness of the term, it was immediately obvious to me that intelligent software agent technology will increasingly become an important component of any ecology or ecosystem that seeks to foster innovation.

-- Jack Krupansky

New book on Service-Oriented Computing

A new book is out entitled "Service-Oriented Computing : Semantics, Processes, Agents" by Munindar P. Singh and Michael N. Huhns. As it's announcement notes:

This comprehensive textbook explains the principles and practice of service-oriented computing with an emphasis on Web services and their construction, deployment, and usage. The book presents the concepts,architectures, theories, techniques, standards, and infrastructure necessary for employing services. It includes a solid overview of the state-of-the-art in Web services and associated disciplines, relating concepts to practical examples and emerging standards. Applicationsof services are explained within the context of ontologies, transactions, processes, planning, negotiation, contracts, compliance, and policies.

The book also has an associated web site.

Please see our complete list of books related to software agent technology.

-- Jack Krupansky Jack@Agtivity.com

Conference session on multi-agent systems and evolutionary computing

What timing... no sooner had I posted my thoughts on exploring evolutionary computing in conjuction with software agents, than I see an announcement for a session at the Conference on Knowledge-Based & Intelligent Information & Engineering Systems entitled "Multi-Agent Systems and Evolutionary Computing". Here's a brief synopsys from the announcement:

This session focuses on the use of the Multi-Agent paradigm for optimization using Evolutionary Computation (i.e. Genetic Algorithms, EvolutionStrategies .). The concept of a computational agent becomes increasinglyimportant in computer science, representing a new level of abstraction for software design. New issues arise when evolutionary computation is applied to the multi-agent paradigm. In these systems evolutionary algorithms must adapt to dynamic problem spaces, where changes are caused by the interactions of the agents in the environment of the global system.Distributed problem solving by a multi-agent system represents a promising approach for solving complex computational problems and has already found its way into many practical applications.

Ideal programming for software agents

I'm just started to sketch out some ideas for a new approach to software agents that I call "Ideal Programming". It's based on a combination of evolutionary programming and constraint programming plus a whole bunch of additional ideas. The essence is an attempt to add structure (which I call "Ideals") for how a programmer controls or influences or gives guidance to an evolutionary algorithm. There's a lot to it than that, but this is the starting point.

There's not much of anything here to read about yet, but you can be sure of one thing, and that's that ideal programming will "evolve".

Maybe it should be called "Ideal-Oriented Prgramming".

Stay tuned.

-- Jack Krupansky Jack@Agtivity.com

Updated software agent definitions again

I've updated my definitions for software agent and software agent system again.

See my discussion of "What is a Software Agent?" for more details.

Concurrent programming for software agents

Concurrent programming is an approach to developing a single computer program in such a way that portions of the program can be allocated to different processors so that they can run in parallel. Software agents are already separate computer programs that can run in parallel, but portions of even a small software agent may in fact be suitable for being parceled out to other processors. In addition, the techniques for coordinating parallel processes may well prove quite useful for coordinating software agents.

See some other comments I've made on concurrent programming on the Base Technology blog.

Updated definitions for Software Agent and Software Agent System

I've revised my definitions for the terms Software Agent and Software Agent System to reflect my accumulated thinking to date. The field of software agents and software agent technology is primarily a research area and even the top researchers are as yet unable to agree on a common definition for even basic terms, so I'll offer my own definitions:

A Software Agent (or Autonomous Agent or Intelligent Agent) is a computer program which works toward goals (as opposed to discrete tasks) in a dynamic environment (where change is the norm) on behalf of another entity (human or computational), possibly over an extended period of time, without continuous direct supervision or control, and exhibits a significant degree of flexibility and even creativity in how it seeks to transform goals into action tasks.

A Software Agent System (or Multi-Agent System (MAS)) is a computational environment (such as the Web or a grid computing environment overlay network) in which individual software agents interact with each other, sometime in a cooperative manner, sometimes in a competitive manner, and sometimes autonomously pursuing their individual goals, accessing resources and services of the environment, occasionally producing results for the entities that initiated those software agents.

For my detailed definition, Click here.

Blog technology

Blogs have gotten a lot of attention, but with so much of the focus on the editorial aspects of "blogging" and the syndication and aggregation aspects, it wasn't until recently that I decided that maybe there really is some future potential for use by software agents.

As blog feeds and blog entries or posts begin to take on more sophistication and structure, it begins to make more sense that software agents really can use blogs (or actually blog feeds) as information sources.

And, it does seem to make sense for software agents to output information in blog form, or actually blog feed form as a stream of information items or blog entries or posts.

It's still too early to really pursue this angle in earnest, but blog technology does seem like it is headed in a direction where its path will intersect that of software agent technology in the not-too-distant future.

Stay tuned.