Updated README.

Author: horned-sphere

README.md

@@ -27,7 +27,85 @@ host can share a single web-socket connection.
 
 ## Examples
 
-TODO
+The following example application runs a SwimOS server that hosts a single agent route where each agent instance
+has single lane, called `lane`. Each time a changes is made to the lane, it will be printed on the console by the
+server.
+
+```rust
+use swimos::{
+    agent::{
+        agent_lifecycle::HandlerContext,
+        agent_model::AgentModel,
+        event_handler::{EventHandler, HandlerActionExt},
+        lanes::ValueLane,
+        lifecycle, AgentLaneModel,
+    },
+    route::RoutePattern,
+    server::{until_termination, Server, ServerBuilder},
+};
+
+#[tokio::main]
+pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    
+    // An agent route consists of the agent definition and a lifecycle.
+    let model = AgentModel::new(ExampleAgent::default, ExampleLifecycle.into_lifecycle());
+
+    let server = ServerBuilder::with_plane_name("Example Plane")
+        .set_bind_addr("127.0.0.1:8080".parse()?) // Bind the server to this address.
+        .add_route(RoutePattern::parse_str("/examples/{id}")?, model) // Register the agent we have defined.
+        .build()
+        .await?;
+
+    // Run the server until we terminate it with Ctrl-C.
+    let (task, handle) = server.run();
+    let (ctrl_c_result, server_result) = tokio::join!(until_termination(handle, None), task);
+
+    ctrl_c_result?;
+    server_result?;
+    Ok(())
+}
+
+// Deriving the `AgentLaneModel` trait makes this type into an agent.
+#[derive(AgentLaneModel)]
+struct ExampleAgent {
+    lane: ValueLane<i32>,
+}
+
+// Any agent type can have any number of lifecycles defined for it. A lifecycle describes
+// how the agent will react to events that occur as it executes.
+#[derive(Default, Clone, Copy)]
+struct ExampleLifecycle;
+
+// The `lifecycle` macro creates an method called `into_lifecycle` for the type, using the
+// annotated event handlers methods in the block.
+#[lifecycle(ExampleAgent)]
+impl ExampleLifecycle {
+    
+    #[on_event(lane)]
+    fn lane_event(
+        &self,
+        context: HandlerContext<ExampleAgent>,
+        value: &i32,
+    ) -> impl EventHandler<ExampleAgent> {
+        let n = *value;
+        context.get_agent_uri().and_then(move |uri| {
+            context.effect(move || {
+                println!("Received value: {} for 'lane' on agent at URI: {}.", n, uri);
+            })
+        })
+    }
+
+}
+```
+
+For example, if a Swim client sends an update, with the value `5`, to the agent at the URI `/examples/name` for the 
+lane `lane`, an instance of `ExampleAgent`, using `ExampleLifecycle`, will be started by the server. The value of the 
+lane will then be set to `5` and the following will be printed on the console:
+
+```
+Received value: 5 for 'lane' on agent at URI: /examples/name.
+```
+
 ## Development
 
-See the [development guide](DEVELOPMENT.md);
+See the [development guide](DEVELOPMENT.md).