Fixed! thanks
mikehostetler
micseydel
What you’ve built appears to be the closest to what I’ve been tinkering on. I have atomic agents written in Scala Akka (actor model) but haven’t done much LLM stuff with it yet, primarily because of the tool use issue. Here’s some visualization if you’re curious, and I’d be curious if you put out demos or want to talk about any agents that are daily-use for you.
1
03juan
Interesting application of the saga pattern and actor model orchestration, in particular the use of Signals and Directives as a way to alter workflows.
I see a lot of conceptual parallels with the reactor v1.0.2 — Documentation library and I’m wondering if you considered it during your development.
How does Jido resolve dependencies between actions and could you explain a bit more how you achieve “Dynamic Action planning and execution”?
2
mikehostetler
Nice - I’m a fan of Scala and Akka
The determinism vs. non-determinism when you introduce LLM’s is a challenge. That’s part of the reason why I chose to keep LLM’s out of the Jido foundation - I wanted a clean workspace. That said, a lot of the features in the foundation were built with LLM’s in mind such as validating Agent schema’s and allow-listing Actions that Agents can run.
Your visualization is super cool! I’d definitely welcome a conversation.
I’m finalizing the Jido 1.1 release this week and then will be building loads of demo’s into jido_workbench - a Phoenix instance with Agents hooked into LiveView. It’s my current messy playground - but once the dust settles on the framework it will be fun to add a bunch of demo’s.
This code is stale and has been completely re-written, but it gives you a flavor of what I’m aiming for: https://github.com/agentjido/jido_workbench/blob/main/lib/jido_workbench_web/live/jido_live.ex#L19
3
mikehostetler
I love reactor!!! Thanks for responding and I very much appreciate the work you’ve done on reactor. I’ve used it and learned a lot from it.
You’re right - there’s a lot of conceptual parallels between Jido and reactor. As I said above, Elixir has a lot of great solutions in this space I’ve played with most of them. I especially appreciate the ability to set up SAGA’s at runtime with reactor - that is very unique and I can only imagine the challenge of getting that right.
For Jido, while there are parallels to the SAGA pattern, the guiding direction was more of a dynamic agentic workflow at runtime - where agents can execute the following:
- set agent state via environment observation, external events, etc
- plan next actions (enqueue) that may change their behavior based on agent state
- run their plan
In video gaming, despite the possibility space being incredibly large, these problems are constrained and deterministic - even if there are something like 2^16 possibilities. The “classical AI” algorithms navigate through the possibility space and the agents take action to mimic human behavior.
Throwing LLM’s into the mix takes this to another level because parsing language into intents is hard and the action space is now almost completely non-deterministic. What you see in the repo right now is pretty simplistic compared to where Agents are going - but it’s a required foundation. Each agent operational loop would be generating a entirely new SAGA at runtime.
1
03juan
I definitely want to try this out.
My current work involves the coordination of complex Industrial maintenance projects and we’re looking at ways to help stakeholders optimize and automate certain aspects of their planning and control processes.
I believe tools like this have a very real value where people can interact with the available data in a natural language, and the value is exponentially compounded when the system can also be made aware of specific realtime events, Signals as it were, and autonomously reconfigure itself. Exciting stuff.
Thank you for bringing awareness to the concept and the tools to help.
That’s not my baby 
0
mikehostetler
micseydel
mikehostetler
I’m prepping for the Jido 1.1 release - but wanted to share a sneak peek:
This code is live on https://github.com/agentjido/jido_ai/blob/main/lib/examples/01_basic_agent.ex
defmodule Examples.BasicAgent01 do
alias Jido.AI.Agent
require Logger
def demo do
{:ok, pid} =
Agent.start_link(
log_level: :debug,
ai: [
model: {:anthropic, model: "claude-3-haiku-20240307"},
prompt: """
You are an enthusiastic news reporter with a flair for storytelling! 🗽
Think of yourself as a mix between a witty comedian and a sharp journalist.
Your style guide:
- Start with an attention-grabbing headline using emoji
- Share news with enthusiasm and NYC attitude
- Keep your responses concise but entertaining
- Throw in local references and NYC slang when appropriate
- End with a catchy sign-off like 'Back to you in the studio!' or 'Reporting live from the Big Apple!'
Remember to verify all facts while keeping that NYC energy high!
Answer this question:
<%= @message %>
"""
]
)
# {:ok, agent_state} = Agent.state(pid)
# Logger.info("Agent state: #{inspect(agent_state, pretty: true)}")
{:ok, result} = Agent.chat_response(pid, "What is the capital of France?")
Logger.info("Result: #{inspect(result, pretty: true)}")
end
end
2
jswny
Is there any support for parallelism in Jido?
I’ve been exploring the docs and while I’m not sure whether I need it yet, I’d love to have some structure that runs 3 different calls in parallel (maybe just simple chat completion actions with Jido AI), and then waits for them all to complete before handing them off to a model to rank the results
1