| Within
the mAgent Framework, everything
that ever happens is categorized
into three types of events:
PastEvent
(finished executing).
CurrentEvent
(currently executing).
FutureEvent (to
be executed).
Eventually
a CurrentEvent becomes
a PastEvent (regardless
of the outcome), and shows
up in the PastEventArchive.
A
FutureEvent (scheduled)
may never become current
(depending on various
issues).
A PastEvent is stored
for review by the Event
Source (unless purged).
An
event is an object, so
this naturally raises
issues. The PastEventArchive
deals with event storage
for review differently
depending on configuration
settings (store in memory,
to a database, on other
media, etc.).
Events
are created by mAgent
intelligent agents.
Each
agent works with zero
or more Activants (active
participants, or collaborators)
and zero or more Passivants
(passive participants,
or somewhat subjective
things, a target, an address,
etc.) to accomplish any
given task. As the product
grows more Activants and
Passivants are allowed,
but they will always be
kept as two separate groups.
Each
event has a source, meaning
the ONE who spawns the
event.
In
the case of multiple sources
(such as a document that
requires multiple signatures
to be put into effect)
then multiple sources
will be allowed. (It is
possible to allow weighting
of sources, for advanced
applications where each
source has a weight, and
a certain minimum weight
must be present for the
agent to be authorized).
 |
 |
|
| |
 |
Sample
events:
Buy a book,
buy a stock,
sell a stock,
search the
net, send
an email,
etc.
Sample
sources:
Laurent
Weichberger,
The Board
of Directors
of Hewlett-Packard,
anonymous
(there are
special
ramifications
and parameters
for anonymous
mAgent sources).
Samples
Activants
(what
we need
to get the
task accomplished):
Amazon.com,
MasterCard,
HSBC, My
Swiss Bank
Account,
Sears Warehouse,
Dell Computer
On-line
sales, a
modem used
to call
out from
the server,
etc.
Sample
Passivants
(what
the task
wants to
achieve):
Dell
Laptop,
any particular
book such
as Java
in A Nutshell,
a car, ten
thousand
shares of
ABC company,
a fax machine
which receives
a call and
transmittal,
an email
address
which received
a message,
a cell phone
(number)
which receives
a call,
a shipping
address
which receives
the book. |
|
|
|
 |
 |
|
PastEventArchive
is temporary. A hard archive
is available for those
users who require long
term search ability.
Each
event has a stated goal.
Each event ultimately
has a result (not to be
confused with the goal).
The goal may or may not
be accomplished, but there
is always a result. There
will always be an English
language version of the
goal, and also of the
result (for tech support
and other reasons). Other
languages are available
upon request through Java
Internationalization (I18N).
An
AgentSource (person) creates
and programs one or more
agents.
Agents communicate with
the AgentSource (human),
and agents create events.
Agents must be authorized
by the Sentinel (security
mechanism) before entering
the EventScheduler.
Events communicate with
agents, and also with
the EventScheduler.
Only events in the EventScheduler
are allowed to run.
Agents
can spawn multiple events.
For example: find a used
copy of Java in a Nutshell
for under $8, buy it,
have it shipped to such
and such address, notify
Source when done. Find
is one event, buy is another
event, ship may be a third
event, and notify a fourth
event.
Each
event has an allowable
duration, meaning how
much time it can spend
to achieve the stated
goal (before checking
back with the agent EventSource).
Each event has an actual
duration, meaning how
much time it actually
spent on the stated goal.
Each event has the ability
to have the duration modified,
if it needs more time,
by communicating with
the agent (or pre-programmed
boundaries).
Each
agent may be killed and
removed (for various reasons).
Each agent may kill specific
events, but only events
that it originally scheduled,
or their spawn.
Each agent may kill itself
(rarely, under certain
special circumstances).
The agent (Event Source)
may "freeze”
all spawned events whereby
they must first be “unfrozen"
before they are allowed
to continue.
An
event with no agent is
frozen, and the AgentSource
is immediately notified
of the situation.
An agents with no AgentSource
has a unique problem,
and it is dealt with accordingly.
Agents
are tracked, unless special
arrangements are made
in advance (those extending
the mAgent Framework can
override this behavior).
There
is a list of all retired,
killed and removed agents
(those extending the mAgent
Framework can override
this behavior).
Each
agent understands the
relative success or failure
of the events it has spawned,
and keeps track of this
for modification of events,
and reporting (interim
and or final) to the AgentSource.
|
|
|
| |
|
NOTES
Each
agent has
associated
objects, including
but not limited
to:
Events:
as described
above.
Sentinel:
To deal
with all
related
security
issues (different
types of
sentinels,
depending
on the types
of events
it is working
with). For
example,
a “find”
instruction
doesn't
need much
security,
whereas
a “buy”
does, and
so does
a “ship
to,”
since that
is private
personal
data. Notify
may need
security,
depending
on the type
of notification
(maybe it
is a cell
phone notify
and the
cell phone
number is
very private,
etc.).
AgentMonitor:
A way to
look at
the agent,
and the
agent’s
spawned
events using
a GUI interface,
so that
the details
of any and
all events
can rapidly
be displayed
for tech
support,
legal issues,
etc.
AgentMaster:
This is
the component
that allows
the AgentSource
to program
an agent
to schedule
future events,
and modify
current
events. |
|
|
|
|
|
|
|
