A couple of weeks ago we had started to take a look at the structure of Infostore,  the VoiceObjects data repository for real-time caller behavior analysis. (Incidentally – yes, the second installment of this series is in the pipeline.)

 Infostore is the basis for statistical data analysis using Business Intelligence (BI) tools such as MicroStrategy (for which a free edition is available), SAP BusinessObjects or IBM Cognos. As such a certain amount of data is required to obtain useful and statistically significant reports. However we realize that many of you would like to explore the capabilities of Infostore even in your development environments using Voxeo VoiceObjects Developer Edition, so in this article we’ll show you how to enable Infostore in this setup. And it’s just about as easy as 1-2-3:

1. Set up a database
   Infostore, being a data repository, requires a relational database to live in. Since it is conceptually designed to hold many millions of records, it currently supports large-scale commercial database systems that can do this with high performance, including Oracle, Microsoft SQL Server, IBM DB2, and PostgreSQL.
   For evaluations all of these provide free versions that can be downloaded; one that is particularly easy to work with and that we’ll use in this article is Microsoft SQL Server Express. Installation and configuration of the database itself is very straightforward. Appendix B of the Installation Guide provides  instructions on how to set things up.
2. Create the Infostore schema
   Once you have a database user and (empty) schema, it is time to create the tables and fill them with initial configuration data. Infostore supports partitioned and non-partitioned tables; in this article we will use the non-partitioned version since the data volume for evaluation will be limited.
   So the first thing to do is to run the script LDCreate.sql that can be found in <EclipseFolder>\plugins\com.voiceobjects.eclipseDesktop_9.0.0\driver\db\SQLServer of your Developer Edition installation. This creates all of the database tables that Infostore needs.
   After this has finished successfully, run LDConfigure.sql from the same folder. This inserts a whole bunch of static look-up data into the tables and prepares Infostore for its use.
3. Configure Developer Edition
   With the preparations of the two preceding steps, we can now point Voxeo VoiceObjects Developer Edition to use this Infostore repository.
   Open the configuration file Eclipse_Configuration.xml that is located in <EclipseFolder>\plugins\com.voiceobjects.eclipseDesktop_9.0.0\config and locate the section System Log Repository Connection. Within this section, there is a single <connection> entry.
   Set its enabled attribute to true (the default entry is false). Then set the correct database type <rdbms>, connection URL <dburl>, user <user> and password <password>.  There are examples for the various supported database types; for SQL Server it will be something like:
               <rdbms>SQLServer</rdbms>
               <dburl>jdbc:jtds:sqlserver://localhost:1433/VODB</dburl>
               <user>voadmin</user>
               <password>voadmin</password>
4. Start Developer Edition and make your calls
   After having changed and saved the configuration file, (re-)start your Developer Edition. If you have configured a Control Center entry for the embedded server, you should see a green light in the System DB Logging column.
   Deploy an application using the Test Application command and make a call either with a media platform such as Voxeo Prophecy or using the Debug Viewer. This will create the first fact record entries in your Infostore repository.
5. Enjoy
   To explore the entries created in Infostore, refer to the sample SQL queries listed here. Or take a look at the Infostore Guide to learn more about advanced features.

As always, if you have any problems, questions, or suggestions do not hesitate to contact our Extreme Support.

And if you want to learn how you can fill your new Infostore repository faster than by manually making calls, join us for our next Developer Jam Session taking place on July 29 at 11am Eastern to learn about LoadTester. Registration is open now.

Imagine a computer that not only understands what you say but also says it the way you can understand. Imagine a computer that you can talk to the way you talk to humans and that responds the way humans respond. Imagine a computer that can read your thoughts and communicate with you as seamlessly as you’ve always wanted it to, since you saw 2001. OK, keep on dreaming. 2001 is in the past, yet still in the future.

But indeed a HAL of a lot has changed since 1968. Now we can build machines that can reliably understand spoken commands, whole phrases or sentences, and react accordingly: provide timetables, transfer money, book tickets, or provide assistance with any kind of problem we might have in today’s life 2.0 (man how I hate this 2.0 thing by now!). And those machines are increasingly built in a way that they use human patterns of communication, allowing for more or less free speech, interactive turn-taking, and relatively natural-sounding computer voices.

Over 9 months ago – man, time flies like an arrow (hey, we can even build machines that understand the ambiguity of this sentence; apparently already way back around 1968) – I wrote my first article on Natural Dialog Management (also check out the 11/05/2008 jam session on this topic). I promised I’d continue on this, so here I am. Today I want to write about how you can make a voice application adapt to the caller with regard to their “speaking style”, the vocabulary they use, “how they speak”. Why should you do this? Think of a doctor trying to explain what’s wrong with you. If he or she doesn’t adapt his or her vocabulary to yours, you might just as well stay home and google the symptoms yourself.

Here are some examples where Adapt-to-me (as we like to call it at Voxeo) makes sense in speech applications:

Synonyms

• If you are a provider of, say, landline telephony as well as high-speed internet, you might have callers calling into your helpline saying “I have problems with my Internet connection” at your first How-Can-I-Help-You input state. Your system might confirm this by saying “I understand you have problems with your DSL, correct?”. Your technology to provide internet might be DSL – but does your customer necessarily know that? How could she respond? Maybe with saying “No, Internet!”?
  Ouch…

Number patterns

• Ever had the experience of giving out your phone number over the phone and hearing it back from your interlocutor in a way you didn’t even recognize your own number anymore? “My number? That’s six two nine three nine oh four.” – “OK, I’ve jotted that down, that’s sixty-two, ninety-three, nine fourteen?” – “Hang-on… let me think… err, yeah I think that’s it.”
  Ouch…

Date patterns

• How do you say the expiration date of your credit card? If it was “12/12”, would you say “twelve twelve”, or “December twelve”, or “December two thousand twelve”, or …
  No ouch this time. This is just to demonstrate that there are numerous ways to speak dates, and using the same pattern as the caller when repeating their input again can help improve intelligibility of the system, thus cause less frustration, thus fuel acceptance of the overall application, thus increase revenue…?

So I say you can have the computer say “internet connection” instead of “DSL”, and “six two nine three nine oh four” (not even “six two nine three nine zero four”), and even “twelve twelve” if that’s what the caller is inclined to say (maybe hastening to add a “that’s December, two-thousand and twelve”, just to confirm you have fully understood your caller). You will say: “How”? Let me explain.

VoiceObjects allows you to store the pronunciation of an utterance in a variable, along with its actual value. This is done through the grammar that enables the speech recognizer to understand the caller in the first place. This value is called the pronunciation value. There is no fixed format for how this value should look like; it is completely up to you. How to hand this value back to VoiceObjects Server from within a grammar is simple: you add it to the return value for the slot that is filled by the corresponding utterance, separated by a double-pipe (“||”).

Example:

When the server detects this “||” symbol (which is configurable through our media platform driver concept, by the way), it will parse the actual value out of it (“DSL”, as this might be the internal value required for further processing) and assign it to the variable, parse the pronunciation value and assign it as well. By the way, if you’re interested in this value during processing, you can retrieve it via the PRONUNCIATION(RefID) function provided by the Expression object.

What you do with this pronunciation value is straightforward, too: you hand it over to a formatting algorithm (via our Formatting Bus), which takes this pronunciation value (along with the “real” value, which is actually not needed for speaking the variable value back) and uses it to come up with the pronunciation when repeating the value in an output. Note how the grammar, in the above example, returns “internet_connection” as the pronunciation value; this assumes that there is a prerecorded prompt saying “internet connection” as the problem category. Your formatting algorithm would thus probably need to return “internet_connection.wav” as the audio file to use for playback. In fact, for this example you don’t even need your own formatting algorithm. The predefined formatting types utilize the pronunciation value instead of the actual variable value anyway. So choosing, e.g., TTA – Files or TTA – Complete as formatting types for your Variable object will make the platform use “internet_connection.wav” right away. Nice and simple.

Let’s have a look at the number pattern example now.

First, your grammar must be built in such a way that it can recognize single digits as well as number blocks. Usually, rules that match “one” up to “ninety-nine” suffice. The rest can be nested using smart grammar rule structures. In the tags that compute the value of what was said (as opposed to the words used), you need to add logic that also builds up the pronunciation value as the caller speaks (or rather: as the ASR engine computes the result). As an example, if the caller in fact says “sixty-two ninety-three nine oh four”, the slot return value computed by your grammar rules might be “6293904||62 93 9 oh 4”, which gets parsed as “6293904” for the actual variable value and “62 93 9 oh 4” for the pronunciation value. Your formatting algorithm might make a sequence of “62.wav 93.wav 9.wav oh.wav 4.wav” out of this. In fact, you could just as well use a predefined TTA algorithm for this again, e.g. TTA – Words, and it will do the job.

Last but not least, our famous sample application Prime Telecom, a telco self-service portal coming in three channels (voice, text, mobile Web), provides a sample implementation of Adapt-to-me with the credit card expiration date example I described above. Go check it out today! You can get all the software required to run this sample application for free at http://developers.voiceobjects.com. Go and impress your boss with what VoiceObjects can do for making your phone applications a much more pleasant experience, and your customers much happier. (Or maybe you ARE the boss? But hey – this mission is too important for me to allow you to jeopardize it…)

Oh, and if your boss tells you to implement this within your existing VoiceObjects app, check out the Input object documentation of our Object Reference (search for “pronunciation value”).

Are you the kind of person who took apart gadgets when you were young, just to see what they looked like on the inside? Are you unafraid of getting your hands a little dirty to better understand how the cogs move the shafts? Then this article is for you!

Voxeo VoiceObjects Developer Edition provides you with an all-in-one framework for building, testing, deploying, and monitoring phone applications using multiple phone channels such as voice, texting, or mobile web. It does this in part by incorporating a full-fledged Voxeo VoiceObjects platform “under the hood”, configured and operated in such a way that you do not need to see or touch it for all standard tasks. Just like the motor in your car it just runs whenever you turn the key, and the only maintenance required is an oil change every now and then. Yet the hood isn’t welded shut, and if you really want to you can sneak a peek inside. As a first step what we’ll do today is to create a Control Center entry for the embedded server, so you can watch its status and activity.

The Control Center is the graphical component that lets you monitor and control VoiceObjects servers, either on their own or in clusters. A detailed description of the functions and capabilities can be found within the Deployment Guide.
To configure a Control Center connection in Voxeo VoiceObjects Developer Edition, open the Eclipse preferences and go to the VoiceObjects section.

The bottom half of the pane lists all configured Control Center connections; initially (as shown in the screen shot) this list is empty. Click “Add…” to add a new connection. This brings up a new window in which to configure the connection.

For a connection to the embedded server we use the default VoiceObjects account voadmin (which, if you haven’t changed it, has the default password manager). Again by default, the port used by the embedded server is 8070. The Testing URL parameter is used by the Debug Viewer, so it isn’t strictly required but convenient to have in place. Finally, an Alias is required to identify the Control Center connection since you can have any number of them.

Once you have defined your Control Center connection and stored the updated preferences, your Control Center view should look like this:

If the Control Center view should not be open in your Eclipse perspective, you can open it from the Window menu.

The first tab within the Control Center view, called Server Manager, gives an overview of the VoiceObjects Server and the corresponding server instances. For the embedded server in Voxeo VoiceObjects Developer Edition, there is only a single server instance on localhost.
The second tab, called Service Manager, lists all services deployed on the server.

On the embedded server, there is only a single service called testService. Do not be unduly alarmed if it shows a yellow warning triangle as in the screen shot above – usually this simply means that you haven’t actually deployed an application yet, so the service doesn’t quite know what to do with itself. A situation that can easily be rectified by deploying an application using the Test Application entry in the Object Browser context menu:

This brings up the Test Monitor view – which actually is a simplified version of the Control Center you have just created!

When you switch back to the Control Center view and click the refresh button (the intertwining green arrows just above the drop-down selection box) your service entry should now be green and happy:

A right-click on the service opens up the context menu of available actions, including the ability to start a Debug Viewer session for the service. This does the exact same thing as clicking the Debug button in the Test Monitor view.

The other context menu entries will no doubt be tempting to play with, but we’d strongly recommend to at least read the documentation before doing so to avoid unexpected results. 
Don’t say we didn’t warn you!

After completing a call in the Debug Viewer and going back to the Control Center view (and possibly hitting the refresh button again) you’ll see your successful call listed in the Finished column.

In this final screen shot, you may notice the black lamp in the System DB Logging column that will show the tool tip Overridden when you place your mouse over it. This is due to the fact that while the service would like to write its statistics to the Infostore database, no appropriate connection has been configured for the server. This is something we’ll jointly rectify next week. Until then you may want to brush up your Infostore knowledge so you’re all set and ready to go.

With your new Control Center entry and the server’s activity in full view, you may be interested in seeing the wheels spin at higher speeds. Our next Developer Jam Session, scheduled for July 29 at 11am Eastern, will feature Andreas Volmer talking about the LoadTester component of the Voxeo VoiceObjects platform which, unsurprisingly, is designed for load testing your applications. Registration is highly recommended!

After we’ve seen last week how to keep the Voxeo VoiceObjects Developer Edition well-oiled, and how to make best use of the Outline view, it’s time this week to take a look at some hands-on tips. We know that tastes differ, and that the keyboard – and particularly the CTRL+C / CTRL+V keys – have a special place in many a developer’s heart. So today we’ll take a look at the shortcut notation that can be used to create object references without ever having to touch your mouse.

Our examples use the Output object, but the same functionality is available in other structurally similar places such as e.g. the Log object. The screenshots in this article use the Canyon theme to provide some diversity.

Voxeo VoiceObjects Developer Edition is based on the concept of drag&drop, and many users will want to assemble their objects e.g by typing static portions and then bringing in object references by dragging them from the Object Browser or from the Object Palette.

This creates a textual reference to the object indicated by square brackets and boldface, e.g. [V:Song]. Double-clicking the reference opens the respective object editor, and the object’s short description is displayed in a tool tip when the mouse hovers over the reference.

Dragging and dropping is swell, but sometimes you know exactly which objects you want to reference and would prefer not to interrupt the flow of typing. And the great thing is that in these cases, you can also just type in the textual reference!

To make this as easy as possible, object references are validated in real time as you type. So when you start with something like [V: and then type the name of the Variable object to be referenced (more on object types below) followed by a closing bracket ] the object reference is recognized and automatically highlighted in boldface.

But what if you mistyped the object name? Well, that’s recognized, too, and indicated by red font and question marks:

You can simply correct the typo (in this case replace the “i” by an “o”) and the reference will again automatically and immediately change into the boldface [V:Song]. Neat, right?
And despite all the extra functionality of being clickable and showing tool tips, the shortcut notation references still are “normal” text, so you can handle them like you would any other text. In particular, you can copy and paste them e.g. from one Output item to another, or from an Output object to a Log object.

Before saving an object you should make sure that all invalid references are corrected. Why?
A correctly established object reference is stored internally as such, i.e. in our example the Voxeo VoiceObjects platform knows that when processing the Output object, it needs to refer to the value of the Variable object “Song”. When saving the Output object with the invalid reference to the “Sing” variable, no such dependency can be established and therefore what you intended as a reference will (need to) be treated as pure text. So instead of “You are about to download Like a Virgin” you’ll hear “You are about to download Sing”.

As mentioned above, the different types of objects that can be referenced using shortcut notation are identified by the initial letter following the opening bracket (note that not all types are appropriate in all places, e.g. an Output object cannot be referenced within a Log object):

• [A:Audio] references an Audio object
• [C:Collection] references a Collection object
• [E:Expression] references an Expression object
• [L:Layer] references a Layer object
• [M:Movie] references a Video object
• [O:Output] references an Output object
• [S:Silence] references a Silence object
• [V:Variable] references a Variable object
• [X:Script] references a Script object (which is eXecutable)

So the next time you need to insert an object reference into your Output item or Log entry, be aware of your options. Nothing wrong with dragging and dropping; nothing wrong with just typing along. All just a matter of taste.

By the way, to pre-empt a common feature request: We know that it would be *really* neat if you could start typing e.g. [V:So and be presented with a list of possible completions. It’s high on our own wish list, too; stay tuned and you may see this and other things show up in future versions.

Finally, if you’re reading this close the date of original posting, there’s still time to register for our next Developer Jam Session. It’s coming up this Wednesday, June 24, at 11am Eastern and deals with Integrating advanced call control in VoiceObjects applications using CCXML.
And if you’ reading this article at your leisure later on – fear not, because our archived jam sessions are available here for your convenience.

After our recent lengthy article on the benefits of the editor outline, today’s is a much shorter but no less important tip when working with Voxeo VoiceObjects Developer Edition.

As you may know, the Developer Edition provides a convenient all-in-one packaging of the entire Voxeo VoiceObjects platform. One of its invisible parts is an embedded database that is used to store all object definitions and deployed services. It is based on the acclaimed Apache Derby DB and usually provides you with excellent, reliable, and fast service whenever you turn the key. In grateful return, you should tend to its needs every now and then.

When you work on your applications, entries in the database are created, modified, and deleted. Over time, this can lead to a certain amount of disorder and dirt that accumulates in the DB tables - engine gunk, as they call it in the car commercials. It can lead to sluggish performance e.g. when opening projects or saving objects. Not to worry, though, since there is an easy solution that you can apply without ever having to open the hood.

From the VoiceObjects menu, select the entry Optimize Embedded Database.

This starts a fully automatic clean-up and optimization process, which may take a couple of minutes depending on how big (and dirty) your database has become.

This time is very well spent, however, since after it is finished you will likely notice a significant boost in responsiveness and performance. Cleaner engines do run faster.

Think of it as an occasional oil change for your IDE. No need to do it on a weekly basis, but every couple of months or whenever you have the feeling that Developer Edition has become noticeably slower than it used to be is a good time.

If you read the Voxeo blogs available at http://blogs.voxeo.com/, you may also know that we alert people to new blog posts through several methods, including our Twitter account at twitter.com/voxeo. I’m pleased to note that posts here at the VoiceObjects Developer Blog will now also appear in that combined Twitter stream. So if you are a Twitter user, please do follow Voxeo on Twitter and you can stay up on all of the various articles we publish.

It’s time for another entry in our “tips and tricks” series on VoiceObjects Developer Edition. Today we want to take a closer look at the editor outline view and how you can use it to quickly find your way in complex object definitions.

Take a look at the List object below (we’re using the Neon theme here for maximum impact):

Feeling lost yet? Don’t! The outline’s here to help.
At its top level, the outline shows all the sections that can be defined for a specific object. All object types have the Definition and the Properties sections. Other sections vary depending on the object type. For example, objects representing input states (such as the Input or Menu object, or indeed our List object) have Event Handling and Tuning sections.

Just like the editor itself, the outline uses color coding to indicate required sections. A section is shown as required as long as it contains at least one undefined required field or sub-section. By expanding the marked sections using the “+” buttons you can drill down into these sub-sections. 

Click on a section header in the outline to open the respective section in the editor. If necessary, the editor will scroll to bring the section into view.

As you define some of the fields in the editor, the color coding of the sections changes and you see the “(…)” icon indicating that the respective section contains entries. In our example we start by filling the Data Definition section:

The Voxeo VoiceObjects platform uses a full object-oriented approach for maximum re-usability, so in particular you can always utilize autonomous objects in place of embedded ones. As an example within our List object, we utilize existing autonomous Output objects instead of defining embedded ones for the Welcome and No Data messages. To do this, simply drag the Output objects on the respective section headers. As they drop into place, the chain link icon symbolizes the reference. In addition, the respective section and all its parents are marked with the “*” icon to indicate unsaved changes.

But the outline doesn’t just show information, it can also be used to modify the object. Right-click on a section header in the outline to get a context menu with options. In the example shown above, you can clear the reference to the autonomous object.
One of the places where the outline really shines is when working with sets of items. The Voxeo VoiceObjects tools use this concept in many places; a straightforward example are output items within an Output object:

Each item is represented by a separate entry in the outline. By default, these entries summarize the key settings made for the respective item – for output items these are the language, the occurrence level, and layer switches. If you define a label for an item, this is used instead.
The more items you have – and in multi-lingual applications using personalization and random prompting there can easily be quite a number – the higher the benefit.

Click on any item in the outline to open it, and to simultaneously close all other items that may be open in the editor on the same nesting level. This reduces visual clutter and makes working with items very efficient, even when there are many of them. Also, using the right-click context menu in the outline, you can add, remove, and clear items without the need to switch to the editor itself.
What we’ve shown here for output items works the same way, of course, for menu items, event handling items, grammar items – just any items you can think of. Isn’t consistency a wonderful thing?

So in summary, the outline provides you with

• a quick overview of sections with content through the “(…)” icon;
• a quick overview of sections with unsaved changes through the “*” icon;
• a quick overview of sections with required fields through color coding;
• a quick indication of linked autonomous objects through the chain link icon;
• an efficient way of navigating to specific places in the object definition;
• an efficient way of modifying the object definition;
• the most efficient way of dealing with sets of items.

In a word: The outline is your friend. Make sure you treat it like one, and you’ll never be lost again.

–Incidentally, to give credit where credit is due: The title line is from the Talking Head’s “The Lady Don’t Mind”. Great stuff, if you happen to like it.

Last Friday we gave you a heads-up that VoiceObjects 9 is available for download. Today we want to look at the release in some more detail and give you an overview of major new functionality that comes with it. For a full list of all enhancements and fixes, check the Release Notes that are part of the documentation in the download package. They are also contained within the Installation Guide.

Event Handling
If you build voice or DTMF applications, you’re familiar with the concept of “event handling” – how to deal with situations in which callers either don’t say anything at all (“No Input”), or something that the application does not expect at this point (“No Match”). Most of the time you want to handle these events by either just giving the caller another chance (e.g. “Sorry, I didn’t get that”) or by providing them with further assistance (e.g. “You may also enter your account number using the keys on your phone.”). Sometimes, however, when there are just too many of these events in a call, you may decide to give up and transfer the caller to a human agent to ensure they get the service they deserve.

VoiceObjects 9 introduces a new event type that makes this easier, called Invalid Answer Limit. It combines No Input and No Match events into a single counter for “invalid answers” and allows you to set a limit on them. So you can say e.g. that after four such events, no matter in which combination or order, the call is to be transferred to a human agent.

Of course, this new event type is fully integrated into the object-oriented approach delivered by the Voxeo VoiceObjects platform. In fact, the primary use case is likely to be that the root Module of your application defines a handler for Invalid Answer Limit that is then automatically applied in all input states of your application.

Text-To-Audio
In all but the simplest applications there is the need to present dynamic data to the caller – be it a package delivery date, an account balance, or a flight departure gate. For optimal quality and blending with the rest of the prompts, this is most typically done by using pre-recorded audio snippets that are assembled on-the-fly. Within the Voxeo VoiceObjects platform, this is referred to as Text-To-Audio (TTA).

VoiceObjects 9 further strengthens the existing rich TTA support by introducing the ability to reference existing dialog objects from within the sequence of audio snippets. Apart from being a logical extension of the previous capabilities, this is also a good example of enhancements driven by user feedback.

Resource Validation
Sophisticated applications frequently use thousands of audio files, often in multiple languages such as English, Spanish and/or French. The Storyboard Manager is a great tool for keeping track of all these files – and it got even better in VoiceObjects 9 by offering automatic resource validation. At the click of a button, it traverses all the various resource folders and makes sure that the required files are available.

You see at a glance whether files are missing, and if so which ones. A major time saver, and a potential life saver in making sure that your callers hear their prompts instead of static.

Logging
By default, the Voxeo VoiceObjects platform logs to rotating files with a variety of configuration options. Some of our large customers expressed the desire to integrate the logs directly with their monitoring framework the way that VoiceObjects already does with SNMP alarming and email notifications. So with VoiceObjects 9 we provide the ability to write to a syslog stream, either instead of writing to log files or in addition to it. One more way to ensure that there is a seamless path from the free Developer Edition on your laptop to a failsafe multi-thousand port deployment in your corporate network.

Support Chat
We take pride in our 24×7 Extreme Support that is there for you whenever you need assistance – because we are successful when you are successful. So to make it easier than ever for you to get in touch with us, we added a new Support Chat entry to VoiceObjects Developer Edition. Within seconds, you can start a chat with a member of our support team and get the information you need.

Never hesitate to make use of it – we genuinely love to hear from you and appreciate your feedback to make our products better.

Instant Messaging
As you will have heard, IMified has joined the Voxeo family recently. That’s great news since it expands your options in building outstanding phone applications even further – and with the built-in support for Instant Messaging and texting available in VoiceObjects since version 7.4, you can have multi-channel applications running in no time. We’ll have a separate blog posting on this soon, and we’re busy working on a deeper integration. This is going to be an exciting summer!

Finally, we’d like to remind you of and invite you to our Developer Jam Session for this month (on June 24, 11am Eastern), in which Tobias Göbel is going to present hands-on information on how to build powerful CCXML applications using the Voxeo VoiceObjects tools and Voxeo Prophecy. Hope to see you there!

VoiceObjects 9.0, the newest version of the Voxeo VoiceObjects platform, is now available for download from the Developer Portal (for the free Developer Edition) as well as from the VoiceObjects Service Portal (for existing customers).

VoiceObjects 9 offers a number of new capabilities e.g. in event handling and in the playback of dynamic data (“Text-To-Audio”). We are going to provide more detailed hands-on descriptions of some of them in a separate blog post during the next couple of days.

In the meantime, download the newest version, take a look at the Release Notes, upgrade your existing applications – and by all means, contact our support team if you have any questions or problems. It’s easier than ever, with a new menu entry right in VoiceObjects Desktop for Eclipse that immediately takes you to our support chat.